08. Create Word Embeddings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Word level one hot encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = [\"The cat sat on the mat.\",\"The dog ate my homework.\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "token_index = {}\n",
    "\n",
    "for sample in samples:\n",
    "    for word in sample.split():\n",
    "        if word not in token_index:\n",
    "            token_index[word] = len(token_index) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_length = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = np.zeros(shape = (len(samples), max_length, max(token_index.values())+ 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, sample in enumerate(samples):\n",
    "    for j, word in list(enumerate(sample.split()))[:max_length]:\n",
    "        index = token_index.get(word)\n",
    "        results[i, j ,index] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Character level one hot encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = [\"The cat sat on the mat.\",\"The dog ate my homework.\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "characters = string.printable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "token_index = dict(zip(range(1, len(characters) + 1), characters))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_length = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = np.zeros((len(samples), max_length, max(token_index.keys()) + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, sample in enumerate(samples):\n",
    "    for j, character in enumerate(sample):\n",
    "        index = token_index.get(character)\n",
    "        results[i, j ,index] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One hot encoding using keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.preprocessing.text import Tokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = [\"The cat sat on the mat.\",\"The dog ate my homework.\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = Tokenizer(num_words=100)\n",
    "tokenizer.fit_on_texts(samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequences = tokenizer.texts_to_sequences(samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "one_hot_results = tokenizer.texts_to_matrix(samples, mode='binary')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_index = tokenizer.word_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 9 unique tokens.\n"
     ]
    }
   ],
   "source": [
    "print('Found %s unique tokens.' % len(word_index))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One hot Hashing Trick"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = [\"The cat sat on the mat.\",\"The dog ate my homework.\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "dimensionality = 1000\n",
    "max_length = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = np.zeros((len(samples), max_length, dimensionality))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, sample in enumerate(samples):\n",
    "    for j, sample in list(enumerate(sample.split()))[:max_length]:\n",
    "        index = abs(hash(word)) % dimensionality\n",
    "        results[i, j, index] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Learning word embeddings with Embedding layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.layers import Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_layer = Embedding(1000, 64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.datasets import imdb\n",
    "from keras import preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_features = 1000\n",
    "maxlen = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = preprocessing.sequence.pad_sequences(x_train, maxlen= maxlen)\n",
    "x_test = preprocessing.sequence.pad_sequences(x_test, maxlen= maxlen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Flatten, Dense"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_2 (Embedding)      (None, 20, 8)             80000     \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 160)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 1)                 161       \n",
      "=================================================================\n",
      "Total params: 80,161\n",
      "Trainable params: 80,161\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()\n",
    "model.add(Embedding(10000, 8, input_length = maxlen))\n",
    "model.add(Flatten())\n",
    "\n",
    "model.add(Dense(1, activation = 'sigmoid'))\n",
    "model.compile(optimizer = 'rmsprop', loss= 'binary_crossentropy', metrics = ['acc'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/akshat/Documents/GHrepos/envs/ml_env/lib/python3.7/site-packages/tensorflow_core/python/framework/indexed_slices.py:424: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
      "  \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 20000 samples, validate on 5000 samples\n",
      "Epoch 1/10\n",
      "20000/20000 [==============================] - 1s 68us/step - loss: 0.6760 - acc: 0.6019 - val_loss: 0.6382 - val_acc: 0.6788\n",
      "Epoch 2/10\n",
      "20000/20000 [==============================] - 1s 55us/step - loss: 0.5741 - acc: 0.7204 - val_loss: 0.5548 - val_acc: 0.7108\n",
      "Epoch 3/10\n",
      "20000/20000 [==============================] - 1s 54us/step - loss: 0.5119 - acc: 0.7487 - val_loss: 0.5352 - val_acc: 0.7196\n",
      "Epoch 4/10\n",
      "20000/20000 [==============================] - 1s 54us/step - loss: 0.4881 - acc: 0.7609 - val_loss: 0.5291 - val_acc: 0.7242\n",
      "Epoch 5/10\n",
      "20000/20000 [==============================] - 1s 54us/step - loss: 0.4760 - acc: 0.7694 - val_loss: 0.5296 - val_acc: 0.7326\n",
      "Epoch 6/10\n",
      "20000/20000 [==============================] - 1s 55us/step - loss: 0.4666 - acc: 0.7742 - val_loss: 0.5307 - val_acc: 0.7292\n",
      "Epoch 7/10\n",
      "20000/20000 [==============================] - 1s 54us/step - loss: 0.4587 - acc: 0.7805 - val_loss: 0.5329 - val_acc: 0.7306\n",
      "Epoch 8/10\n",
      "20000/20000 [==============================] - 1s 53us/step - loss: 0.4509 - acc: 0.7869 - val_loss: 0.5366 - val_acc: 0.7298\n",
      "Epoch 9/10\n",
      "20000/20000 [==============================] - 1s 54us/step - loss: 0.4434 - acc: 0.7898 - val_loss: 0.5407 - val_acc: 0.7262\n",
      "Epoch 10/10\n",
      "20000/20000 [==============================] - 1s 54us/step - loss: 0.4365 - acc: 0.7957 - val_loss: 0.5467 - val_acc: 0.7212\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(x_train, y_train, epochs = 10, batch_size = 32, validation_split = 0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Pre trained Embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "imdb_dir = 'datasets/aclImdb'\n",
    "train_dir = os.path.join(imdb_dir, 'train')\n",
    "\n",
    "labels = []\n",
    "texts = []\n",
    "\n",
    "for label_type in ['neg', 'pos']:\n",
    "    dir_name = os.path.join(train_dir, label_type)\n",
    "    for fname in os.listdir(dir_name):\n",
    "        if fname[-4:] == '.txt':\n",
    "            f = open(os.path.join(dir_name, fname))\n",
    "            texts.append(f.read())\n",
    "            f.close()\n",
    "            if label_type == 'neg':\n",
    "                labels.append(0)\n",
    "            else:\n",
    "                labels.append(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tokenize the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxlen = 100\n",
    "training_samples = 200\n",
    "validation_samples = 10000\n",
    "max_words = 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 88582 unique tokens.\n",
      "Shape of data tensor: (25000, 100)\n",
      "Shape of label tensor: (25000,)\n"
     ]
    }
   ],
   "source": [
    "tokenizer = Tokenizer(num_words=max_words)\n",
    "tokenizer.fit_on_texts(texts)\n",
    "sequences = tokenizer.texts_to_sequences(texts)\n",
    "\n",
    "word_index = tokenizer.word_index\n",
    "print('Found %s unique tokens.' % len(word_index))\n",
    "\n",
    "data = pad_sequences(sequences, maxlen=maxlen)\n",
    "\n",
    "labels = np.asarray(labels)\n",
    "print('Shape of data tensor:', data.shape)\n",
    "print('Shape of label tensor:', labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices = np.arange(data.shape[0])\n",
    "np.random.shuffle(indices)\n",
    "data = data[indices]\n",
    "labels = labels[indices]\n",
    "\n",
    "x_train = data[:training_samples]\n",
    "y_train = labels[:training_samples]\n",
    "x_val = data[training_samples: training_samples + validation_samples]\n",
    "y_val = labels[training_samples: training_samples + validation_samples]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download the Glove Vector Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "glove_dir = 'datasets/glove6b'\n",
    "embeddings_index = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "for line in f:\n",
    "    values = line.split()\n",
    "    word = values[0]\n",
    "    coefs = np.asarray(values[1:], dtype = 'float32')\n",
    "    embeddings_index[word] = coefs\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Foudn 400000 word word vectors. \n"
     ]
    }
   ],
   "source": [
    "print('Foudn %s word word vectors. '% len(embeddings_index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_dim = 100\n",
    "embedding_matrix = np.zeros((max_words, embedding_dim))\n",
    "for word, i in word_index.items():\n",
    "    if i < max_words:\n",
    "        embedding_vector = embeddings_index.get(word)\n",
    "        if embedding_vector is not None:\n",
    "            embedding_matrix[i] = embedding_vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_5\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_6 (Embedding)      (None, 100, 100)          1000000   \n",
      "_________________________________________________________________\n",
      "flatten_5 (Flatten)          (None, 10000)             0         \n",
      "_________________________________________________________________\n",
      "dense_8 (Dense)              (None, 32)                320032    \n",
      "_________________________________________________________________\n",
      "dense_9 (Dense)              (None, 1)                 33        \n",
      "=================================================================\n",
      "Total params: 1,320,065\n",
      "Trainable params: 1,320,065\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Sequential()\n",
    "model.add(Embedding(max_words, embedding_dim, input_length = maxlen))\n",
    "model.add(Flatten())\n",
    "\n",
    "model.add(Dense(32, activation = 'relu'))\n",
    "model.add(Dense(1, activation = 'sigmoid'))\n",
    "model.compile(optimizer = 'rmsprop', loss= 'binary_crossentropy', metrics = ['acc'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.layers[0].set_weights([embedding_matrix])\n",
    "model.layers[0].trainable = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/akshat/Documents/GHrepos/envs/ml_env/lib/python3.7/site-packages/keras/engine/training.py:297: UserWarning: Discrepancy between trainable weights and collected trainable weights, did you set `model.trainable` without calling `model.compile` after ?\n",
      "  'Discrepancy between trainable weights and collected trainable'\n",
      "/home/akshat/Documents/GHrepos/envs/ml_env/lib/python3.7/site-packages/tensorflow_core/python/framework/indexed_slices.py:424: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
      "  \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 200 samples, validate on 10000 samples\n",
      "Epoch 1/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 1.4677 - acc: 0.4900 - val_loss: 0.6932 - val_acc: 0.5163\n",
      "Epoch 2/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.6621 - acc: 0.6600 - val_loss: 0.8677 - val_acc: 0.4967\n",
      "Epoch 3/10\n",
      "200/200 [==============================] - 0s 2ms/step - loss: 0.5198 - acc: 0.7200 - val_loss: 1.7895 - val_acc: 0.4964\n",
      "Epoch 4/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.4825 - acc: 0.8350 - val_loss: 1.5148 - val_acc: 0.5034\n",
      "Epoch 5/10\n",
      "200/200 [==============================] - 0s 2ms/step - loss: 0.4337 - acc: 0.8350 - val_loss: 1.7646 - val_acc: 0.5046\n",
      "Epoch 6/10\n",
      "200/200 [==============================] - 0s 2ms/step - loss: 0.2893 - acc: 0.8850 - val_loss: 0.7397 - val_acc: 0.5646\n",
      "Epoch 7/10\n",
      "200/200 [==============================] - 0s 2ms/step - loss: 0.0721 - acc: 0.9950 - val_loss: 0.7936 - val_acc: 0.5524\n",
      "Epoch 8/10\n",
      "200/200 [==============================] - 0s 2ms/step - loss: 0.0374 - acc: 1.0000 - val_loss: 0.8499 - val_acc: 0.5484\n",
      "Epoch 9/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.0211 - acc: 1.0000 - val_loss: 1.0263 - val_acc: 0.5256\n",
      "Epoch 10/10\n",
      "200/200 [==============================] - 0s 2ms/step - loss: 0.0150 - acc: 1.0000 - val_loss: 0.8117 - val_acc: 0.5716\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(x_train, y_train,\n",
    "                   epochs = 10,\n",
    "                   batch_size=32,\n",
    "                   validation_data = (x_val, y_val))\n",
    "model.save_weights('datasets/pre_trained_glove_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3deXxU9b3/8deHTQwgyKZIhKCCqEW2iAJaweUWlx9cXFowVdBW6n6lVn94XaB66bWVe/V6q7VxX6JovUppRb2KWm2xClK0gqKIAYJLIwICYQt87h/fSTIZskzCJDM5eT8fj3nMnGXO+cxJ8s53vmczd0dERJq+FukuQEREUkOBLiISEQp0EZGIUKCLiESEAl1EJCIU6CIiEaFAjzAze8HMJqV63nQys0IzO6UBlutmdljs9b1mdlMy89ZjPXlm9r/1rVOkJqbj0DOLmW2OG8wCtgO7YsM/cfeCxq8qc5hZIfBjd38lxct1oK+7r0jVvGaWA3wGtHb30lTUKVKTVukuQCpz9/Zlr2sKLzNrpZCQTKHfx8ygLpcmwsxGmVmRmf1/M/sSeMjM9jezP5pZsZmtj73OjnvP62b249jryWb2ZzObFZv3MzM7rZ7z9jGzN8xsk5m9YmZ3m9nj1dSdTI23mtlfYsv7XzPrGjf9fDNbZWbrzOyGGrbPsWb2pZm1jBs33szej70eZmZvmdkGM/vCzH5tZm2qWdbDZvZvccPXxt7zuZldlDDvGWb2NzP71szWmNmMuMlvxJ43mNlmMxtetm3j3j/CzBaa2cbY84hkt00dt3NnM3so9hnWm9mcuGnjzGxJ7DN8amZjYuMrdW+Z2Yyyn7OZ5cS6nn5kZquBV2Pjfxf7OWyM/Y4cFff+fc3sP2I/z42x37F9zex5M7sy4fO8b2bjq/qsUj0FetNyINAZ6A1MIfz8HooN9wK2Ar+u4f3HAsuBrsCvgAfMzOox7xPAO0AXYAZwfg3rTKbG84ALge5AG+BnAGZ2JPCb2PIPiq0vmyq4+9vAFuCkhOU+EXu9C5ga+zzDgZOBy2qom1gNY2L1nAr0BRL777cAFwCdgDOAS83sn2PTvht77uTu7d39rYRldwaeB+6Kfbb/BJ43sy4Jn2GPbVOF2rbzY4QuvKNiy7ojVsMw4FHg2thn+C5QWN32qMKJwBHA92LDLxC2U3dgMRDfRTgLGAqMIPweXwfsBh4Bflg2k5kNBHoSto3UhbvrkaEPwh/WKbHXo4AdQNsa5h8ErI8bfp3QZQMwGVgRNy0LcODAusxLCItSICtu+uPA40l+pqpqvDFu+DLgxdjrm4HZcdPaxbbBKdUs+9+AB2OvOxDCtnc1814NPBc37MBhsdcPA/8We/0gcFvcfP3i561iuXcCd8Re58TmbRU3fTLw59jr84F3Et7/FjC5tm1Tl+0M9CAE5/5VzPfbsnpr+v2LDc8o+znHfbZDaqihU2yejoR/OFuBgVXM1xZYT9gvASH472nsv7coPNRCb1qK3X1b2YCZZZnZb2NfYb8lfMXvFN/tkODLshfuXhJ72b6O8x4EfBM3DmBNdQUnWeOXca9L4mo6KH7Z7r4FWFfdugit8bPMbB/gLGCxu6+K1dEv1g3xZayOXxBa67WpVAOwKuHzHWtmr8W6OjYClyS53LJlr0oYt4rQOi1T3bappJbtfDDhZ7a+irceDHyaZL1VKd82ZtbSzG6Lddt8S0VLv2vs0baqdcV+p58CfmhmLYCJhG8UUkcK9KYl8ZCka4DDgWPdfT8qvuJX142SCl8Anc0sK27cwTXMvzc1fhG/7Ng6u1Q3s7svIwTiaVTuboHQdfMRoRW4H/Cv9amB8A0l3hPAXOBgd+8I3Bu33NoOIfuc0EUSrxewNom6EtW0ndcQfmadqnjfGuDQapa5hfDtrMyBVcwT/xnPA8YRuqU6ElrxZTV8DWyrYV2PAHmErrAST+iekuQo0Ju2DoSvsRti/bHTG3qFsRbvImCGmbUxs+HA/2ugGp8BzjSz42M7MG+h9t/ZJ4B/IQTa7xLq+BbYbGb9gUuTrOFpYLKZHRn7h5JYfwdC63dbrD/6vLhpxYSujkOqWfY8oJ+ZnWdmrczsB8CRwB+TrC2xjiq3s7t/Qejbvie287S1mZUF/gPAhWZ2spm1MLOese0DsASYEJs/FzgniRq2E75FZRG+BZXVsJvQffWfZnZQrDU/PPZtiliA7wb+A7XO602B3rTdCexLaP38FXixkdabR9ixuI7Qb/0U4Q+5KvWu0d2XApcTQvoLQj9rUS1ve5Kwo+5Vd/86bvzPCGG7CbgvVnMyNbwQ+wyvAitiz/EuA24xs02EPv+n495bAswE/mLh6JrjEpa9DjiT0LpeR9hJeGZC3cmqbTufD+wkfEv5B2EfAu7+DmGn6x3ARuBPVHxruInQol4P/JzK33iq8ijhG9JaYFmsjng/A/4OLAS+AX5J5Qx6FBhA2Ccj9aATi2SvmdlTwEfu3uDfECS6zOwCYIq7H5/uWpoqtdClzszsGDM7NPYVfQyh33RObe8TqU6sO+syID/dtTRlCnSpjwMJh9RtJhxDfam7/y2tFUmTZWbfI+xv+Irau3WkBupyERGJCLXQRUQiIm0X5+ratavn5OSka/UiIk3Su++++7W7d6tqWtoCPScnh0WLFqVr9SIiTZKZJZ5dXE5dLiIiEaFAFxGJCAW6iEhEZNQdi3bu3ElRURHbtm2rfWZJi7Zt25KdnU3r1q3TXYqIJMioQC8qKqJDhw7k5ORQ/X0XJF3cnXXr1lFUVESfPn3SXY6IJKi1y8XMHjSzf5jZB9VMNzO7y8xWxG4bNaS+xWzbto0uXboozDOUmdGlSxd9g5KkFRRATg60aBGeC9J0i/PmUkcyfegPA2NqmH4a4ZZTfQm3RfvN3hSkMM9s+vlIsgoKYMoUWLUK3MPzlCmNH6bNqY5aA93d3yBc6rI644BHPfgr4S4pPVJVoIjUXSa0SG+4AUpKKo8rKQnjVUfD1JGKo1x6UvkWXUVUvoVWOTObYmaLzGxRcXFxCladWuvWrWPQoEEMGjSIAw88kJ49e5YP79ixo8b3Llq0iKuuuqrWdYwYMaLWeUT2Rqa0SFevrtt41bH3GvWwRXfPd/dcd8/t1q3KM1frJNWtkC5durBkyRKWLFnCJZdcwtSpU8uH27RpQ2lpabXvzc3N5a677qp1HQsWLNi7IkVqkSkt0l6JN+urZbzq2HupCPS1VL7nYjb1uydinTRWK2Ty5MlccsklHHvssVx33XW88847DB8+nMGDBzNixAiWL18OwOuvv86ZZ54JwIwZM7jooosYNWoUhxxySKWgb9++ffn8o0aN4pxzzqF///7k5eWV3QGdefPm0b9/f4YOHcpVV11Vvtx4hYWFnHDCCQwZMoQhQ4ZU+kfxy1/+kgEDBjBw4ECmTZsGwIoVKzjllFMYOHAgQ4YM4dNP9+a+wJLJMqVFOnMmZGVVHpeVFcarjgaqw91rfRBu9vpBNdPOINyv0IDjgHeSWebQoUM90bJly/YYV53evd1DlFd+9O6d9CJqNH36dL/99tt90qRJfsYZZ3hpaam7u2/cuNF37tzp7u4vv/yyn3XWWe7u/tprr/kZZ5xR/t7hw4f7tm3bvLi42Dt37uw7duxwd/d27dqVz7/ffvv5mjVrfNeuXX7cccf5m2++6Vu3bvXs7GxfuXKlu7tPmDChfLnxtmzZ4lu3bnV3948//tjLtue8efN8+PDhvmXLFnd3X7dunbu7Dxs2zJ999ll3d9+6dWv59Pqoy89JGl9D/23UxeOPh/WahefHH2/8GqJWB7DIq8nVWo9DN7MngVFAVzMrItx8tnXsn8G9hBvdnk6432IJ4f6EDa4xWyHnnnsuLVu2BGDjxo1MmjSJTz75BDNj586dVb7njDPOYJ999mGfffahe/fufPXVV2RnZ1eaZ9iwYeXjBg0aRGFhIe3bt+eQQw4pP8574sSJ5OfveROXnTt3csUVV7BkyRJatmzJxx9/DMArr7zChRdeSFasKdC5c2c2bdrE2rVrGT9+PBBODpLomjkzfFuN73ZJR4sUIC8vPNKtudRRa6C7+8RapjvhRr6Nqlev0M1S1fhUa9euXfnrm266idGjR/Pcc89RWFjIqFGjqnzPPvvsU/66ZcuWVfa/JzNPde644w4OOOAA3nvvPXbv3q2QlnJlgXHDDaGB06tXCPNMCDRpWE32Wi7p6hfbuHEjPXuGg3gefvjhlC//8MMPZ+XKlRQWFgLw1FNV35x+48aN9OjRgxYtWvDYY4+xa9cuAE499VQeeughSmLNs2+++YYOHTqQnZ3NnDnhtp/bt28vny7RlJcHhYWwe3d4Vpg3D0020PPyID8fevcGs/Ccn9/wv7jXXXcd119/PYMHD65TizpZ++67L/fccw9jxoxh6NChdOjQgY4dO+4x32WXXcYjjzzCwIED+eijj8q/RYwZM4axY8eSm5vLoEGDmDVrFgCPPfYYd911F0cffTQjRozgyy+/THntIpJeabunaG5urife4OLDDz/kiCOOSEs9mWTz5s20b98ed+fyyy+nb9++TJ06Nd1lldPPSSR9zOxdd8+talqTbaFH2X333cegQYM46qij2LhxIz/5yU/SXZKINAEZdbVFCaZOnZpRLXIRaRrUQhcRiQgFuohIRCjQRUQiQoEuIhIRCvQ4o0eP5qWXXqo07s477+TSSy+t9j2jRo2i7PDL008/nQ0bNuwxz4wZM8qPB6/OnDlzWLZsWfnwzTffzCuvvFKX8kWkmVOgx5k4cSKzZ8+uNG727NlMnFjj1Q/KzZs3j06dOtVr3YmBfsstt3DKKafUa1ki0jwp0OOcc845PP/88+U3sygsLOTzzz/nhBNO4NJLLyU3N5ejjjqK6dOnV/n+nJwcvv76awBmzpxJv379OP7448svsQvhGPNjjjmGgQMHcvbZZ1NSUsKCBQuYO3cu1157LYMGDeLTTz9l8uTJPPPMMwDMnz+fwYMHM2DAAC666CK2b99evr7p06czZMgQBgwYwEcffbRHTbrMrkjzkbHHoV99NSxZktplDhoEd95Z/fTOnTszbNgwXnjhBcaNG8fs2bP5/ve/j5kxc+ZMOnfuzK5duzj55JN5//33Ofroo6tczrvvvsvs2bNZsmQJpaWlDBkyhKFDhwJw1llncfHFFwNw44038sADD3DllVcyduxYzjzzTM4555xKy9q2bRuTJ09m/vz59OvXjwsuuIDf/OY3XH311QB07dqVxYsXc8899zBr1izuv//+Su/v3r07L7/8Mm3btuWTTz5h4sSJLFq0iBdeeIHf//73vP3222RlZfHNN+Eug3l5eUybNo3x48ezbds2du/eXa9tLSKNTy30BPHdLvHdLU8//TRDhgxh8ODBLF26tFL3SKI333yT8ePHk5WVxX777cfYsWPLp33wwQeccMIJDBgwgIKCApYuXVpjPcuXL6dPnz7069cPgEmTJvHGG2+UTz/rrLMAGDp0aPkFveLt3LmTiy++mAEDBnDuueeW153sZXazEq+AJiIZK2Nb6DW1pBvSuHHjmDp1KosXL6akpIShQ4fy2WefMWvWLBYuXMj+++/P5MmT2bZtW72WP3nyZObMmcPAgQN5+OGHef311/eq3rJL8FZ3+V1dZlek+VALPUH79u0ZPXo0F110UXnr/Ntvv6Vdu3Z07NiRr776ihdeeKHGZXz3u99lzpw5bN26lU2bNvGHP/yhfNqmTZvo0aMHO3fupCDufnkdOnRg06ZNeyzr8MMPp7CwkBUrVgDhqoknnnhi0p9Hl9kVaT4U6FWYOHEi7733XnmgDxw4kMGDB9O/f3/OO+88Ro4cWeP7hwwZwg9+8AMGDhzIaaedxjHHHFM+7dZbb+XYY49l5MiR9O/fv3z8hAkTuP322xk8eHClHZFt27bloYce4txzz2XAgAG0aNGCSy65JOnPosvsijQfunyu1Jl+TiLpo8vniog0Awp0EZGIyLhAT1cXkCRHPx+RzJVRgd62bVvWrVun0MhQ7s66det06KNIhsqo49Czs7MpKiqiuLg43aVINdq2bUt2dna6yxCRKmRUoLdu3Zo+ffqkuwwRkSYpo7pcRESk/hToIiIRoUAXEYkIBbqISEQo0EVEIkKBLiISEUkFupmNMbPlZrbCzKZVMb23mc03s/fN7HUz04HKIiKNrNZAN7OWwN3AacCRwEQzOzJhtlnAo+5+NHAL8O+pLlRERGqWTAt9GLDC3Ve6+w5gNjAuYZ4jgVdjr1+rYrqIiDSwZAK9J7AmbrgoNi7ee8BZsdfjgQ5m1iVxQWY2xcwWmdkind4vIpJaqdop+jPgRDP7G3AisBbYlTiTu+e7e66753br1i1FqxYREUjuWi5rgYPjhrNj48q5++fEWuhm1h442903pKpIERGpXTIt9IVAXzPrY2ZtgAnA3PgZzKyrmZUt63rgwdSWKdI0FBRATg60aBGe4+4DLtLgag10dy8FrgBeAj4Ennb3pWZ2i5mNjc02ClhuZh8DBwAzG6hekYxVUABTpsCqVeAenqdMUahL48mom0SLNGU5OSHEE/XuDYWFjV2NRJVuEi3SCFavrtt4kVRToIukSK9edRsvkmoKdJEUmTkTsrIqj8vKCuNFGoMCXSRF8vIgPz/0mZuF5/z8MF6kMWTUPUVFmrq8PAW4pI9a6CIiEaFAFxGJCAW6iEhEKNBFRCJCgS4iEhEKdBGRiFCgi4hEhAJdRCQiFOgiIhGhQBcRiQgFuohIRCjQZa9lym3XMqUOkXTRxblkr5Tddq2kJAyX3XYNGvciVZlSh0g66RZ0slcy5bZrmVKHSEPTLeikwWTKbdcypQ6RdFKgy17JlNuuZUodIumkQJe9kim3XcuUOkTSSYEueyVTbruWKXWIpJN2ioqINCHaKSoi0gwo0EVEIkKBLiISEQp0EZGIUKCLiESEAl1EJCKSCnQzG2Nmy81shZlNq2J6LzN7zcz+Zmbvm9npqS9VRERqUmugm1lL4G7gNOBIYKKZHZkw243A0+4+GJgA3JPqQkVEpGbJtNCHASvcfaW77wBmA+MS5nFgv9jrjsDnqStRRESSkUyg9wTWxA0XxcbFmwH80MyKgHnAlVUtyMymmNkiM1tUXFxcj3JFRKQ6qdopOhF42N2zgdOBx8xsj2W7e76757p7brdu3VK0ahERgeQCfS1wcNxwdmxcvB8BTwO4+1tAW6BrKgoUEZHkJBPoC4G+ZtbHzNoQdnrOTZhnNXAygJkdQQh09amIiDSiWgPd3UuBK4CXgA8JR7MsNbNbzGxsbLZrgIvN7D3gSWCyp+syjiIizVRSN4l293mEnZ3x426Oe70MGJna0kREpC50pqiISEQo0EVEIkKBLiISEQp0EZGIUKCLiESEAl1EJCIU6CIiEaFAFxGJCAW6iEhEKNBFRCJCgS4iEhEKdBGRiFCgi4hEhAJdRCQiFOgiIhGhQBcRiQgFuohIRCjQRUQiQoEuIhIRCnQRkYhQoIuIRIQCXUQkIhToTVhBAeTkQIsW4bmgIN0ViUg6tUp3AVI/BQUwZQqUlIThVavCMEBeXvrqEpH0UQu9ibrhhoowL1NSEsaLSPOkQG+iVq+u23gRiT4FehPVq1fdxotI9CnQm6iZMyErq/K4rKwwXkSaJwV6E5WXB/n50Ls3mIXn/HztEBVpzpI6ysXMxgD/BbQE7nf32xKm3wGMjg1mAd3dvVMqC5U95eUpwEWkQq2BbmYtgbuBU4EiYKGZzXX3ZWXzuPvUuPmvBAY3QK0iIlKDZLpchgEr3H2lu+8AZgPjaph/IvBkKooTEZHkJRPoPYE1ccNFsXF7MLPeQB/g1b0vTURE6iLVO0UnAM+4+66qJprZFDNbZGaLiouLU7xqEZHmLZlAXwscHDecHRtXlQnU0N3i7vnunuvuud26dUu+ShERqVUygb4Q6GtmfcysDSG05ybOZGb9gf2Bt1JbooiIJKPWQHf3UuAK4CXgQ+Bpd19qZreY2di4WScAs93dG6ZUERGpSVLHobv7PGBewribE4ZnpK4sERGpK50pKiISEQp0EZGIUKCLiESEAl1EJCIU6CIiEaFAFxGJCAW6iEhEKNDroaAAcnKgRYvwXFCQ7opERJI8sUgqFBTAlClQUhKGV60Kw6CbTYhIeqmFXkc33FAR5mVKSsJ4EZF0UqDX0erVdRsvItJYFOh11KtX3caLiDQWBXodzZwJWVmVx2VlhfEiIumkQK+jvDzIz4fevcEsPOfna4eoiKSfjnKph7w8BbiIZB610EVEIkKBLiISEQp0EZGIUKCLiESEAl1EJCIU6CIiEaFAFxGJCAW6iEhEKNBFRCJCgS4iEhEKdBGRiFCgi4hEhAJdRCQiFOgiIhGhQBcRiYikAt3MxpjZcjNbYWbTqpnn+2a2zMyWmtkTqS1TRERqU+sNLsysJXA3cCpQBCw0s7nuvixunr7A9cBId19vZt0bqmAREalaMi30YcAKd1/p7juA2cC4hHkuBu529/UA7v6P1JYpIiK1SSbQewJr4oaLYuPi9QP6mdlfzOyvZjamqgWZ2RQzW2Rmi4qLi+tXsYiIVClVO0VbAX2BUcBE4D4z65Q4k7vnu3uuu+d269YtRasWERFILtDXAgfHDWfHxsUrAua6+053/wz4mBDwIiLSSJIJ9IVAXzPrY2ZtgAnA3IR55hBa55hZV0IXzMoU1ikiIrWoNdDdvRS4AngJ+BB42t2XmtktZjY2NttLwDozWwa8Blzr7usaqmgREdmTuXtaVpybm+uLFi1Ky7pFRJoqM3vX3XOrmqYzRUVEIkKBLiISEQp0EZGIUKCLiESEAl1EpJFs3gy/+AWsXt0wy1egi4g0sO3b4b//Gw49FG64AebMaZj11Hq1RRERqZ9du+Dxx2H6dFi1CkaNCmE+fHjDrE+BLpJic+fCffdBjx6hRXbYYeFx6KHQvn26q5PG4B6C+8YbYdkyGDoU8vPh1FPBrOHWq0AXSZFvv4Wrr4aHHoLsbHj7bUi8qOiBB1aEe1nQlz067XE5O2mK5s+Hf/1XeOcdOPxw+N3v4OyzGzbIyyjQRVLg9ddh8mRYsyb8MU+fDm3awMaN8Omn4bFiRcXjlVfgkUcqL6NLl6qD/tBDoVu3xgkEqb933gk/+/nz4eCD4YEH4IILoFUjpqwCXWQvbNsW/ojvuCOE75//XLl/tGNHGDIkPBKVlMDKlRUhXxb6CxbA7Nmwe3fFvB067BnyZa979IAWOrwhbZYtC10rzz0HXbuG34VLLoG2bRu/FgW6SD29+25ogS1bBpddBr/6FbRrl/z7s7LgO98Jj0Tbt0Nh4Z4t+yVLQnCUllbMu+++FQGf2MLPzm7cFmJzUlgIM2bAY4+FfSO33BK63Dp0SF9N+lGL1NHOnfDv/w633grdu8OLL8L3vpfadeyzT+h/PfzwPaeVloaunfig//RT+OSTUMu2bZXn33ff8I+mffuKR03DycybldV8vxV89RXMnAn33gstW8JPfwrTpoUus3RToIvUwfLlcP75sHAhnHce/PrXsP/+jVtDq1bQp094nHpq5Wm7d8Pnn1e07IuKYMuWcELL5s2VXxcX7zmtLtq1S/4fQ04OnHRS6FtuqjZsgFmz4M47wz/NH/0IbropfAvKFAp0kSTs3g133w3XXRdap089Bd//frqr2lOLFiFgsrPhxBPr9t7du2Hr1oqAT/wHUNvwli2waRN88UXlaVu3Vqyjb184+eTwGD06M1q1tSkpCf+4b7sN1q+HCRNC90rfDLwnmwJdpBZr1sCFF4ajF04/He6/P+yIjJoWLSpa3QcckLrllpbC0qVh+82fH060uffecNTOoEEVAX/CCXXbB9HQdu4MP+tbbw3/pE4/PXS1DBqU7sqqpxtciFTDPYTPlVeGULrjDvjxj3X44N7auTN0WZUF/FtvwY4d0Lo1HHdcRcAPGxYO/Wxsu3fDk0/CzTeHo5COPz5cf+WEExq/lqrUdIMLBbpIFYqLw6Fnzz4b/qAfeQQOOSTdVUVTSUk43LMs4BcvDv9M27ULIVoW8AMHNuyOWHf44x/DtVb+/vewvl/8Ak47LbP+idcU6OpyEUkwdy5cfHHYCfarX4WjGFq2THdV0ZWVBf/0T+EB8M038Kc/VQT8tdeG8V26hH73soA/7LDUBe2f/hTOJ1iwICz3ySfDPpKmdiSPAl0k5ttvYepUePDB0Dp75RUYMCDdVTU/nTvD+PHhAbB2Lbz6akXAP/NMGH/wwRXhftJJcNBBdV/X4sUhyF96Kbz/t78N+0tat07d52lM6nIRIbTQJk0KO0CnTas4dV8yi3s43r4s3F97LbToAfr3rwj4UaNqPpx0+fJwyOHvfhf+gVx/PVx+eThmP9OpD12kGtu2hT7TO+4IZ1k++mjDXdpUUm/3bnjvvYqAf+ON0CffokW43EJZwI8cGbp21qyBn/8cHn44nJr/05/CNdeESzQ0FQp0kSosXhxOElq2DC69FG6/PbMOm5O627EjXOWyLOD/+tdwhFKbNuEStmU7XC+9NHS1dO+e7orrToEuEqe0NJwk8vOfhz/oBx9M/an7khk2b644gubNN8N1c266CXr3Tndl9aejXERili8PF9R65530nbovjad9exgzJjyagyZ2UE44nTjx4kMitdm9O9zTcfDgcI2Tp56CggKFuURLkwv0Bx8MOzCGDw87M555JlyMSKQ6a9aELpWrrgpHP/z975l5HRaRvdXkAv2448I1h1u1gnvugXPPhZ49Q5/YxIlw112waFE4vViat7JT9wcMCKeX5+fD88/X73hlkaagyfWhH3NMeEDYo71kSfhjXbAA/vKXcKcXCMeTHnNMaMmPGBGeu3VLX93SuIqLw5EM//M/4ZC1Rx4JhyWKRFnkjnIpKqoI+LfeCocplbXWDzuscsB/5zs6pTuK/vCHcOr++vXhSnnXXKOfs0THXh+2aGZjgP8CWgL3u/ttCdMnA7cDa2Ojfu3u99e0zMY6bHHr1hDqZQG/YEG44wiEW0UNG1YR8Mcdp51k9VVaGm6btmtXeJ2u52XL4Ikn4Oijw63Bjhydhj8AAAW3SURBVD463VtGJLX26rBFM2sJ3A2cChQBC81srrsvS5j1KXe/Yq+rTbF99w1fuUeODMPu4V6ACxZUhPzMmRU35D3iiIqAHzEi3AKsqV2gZ2+5h+N3v/46dF2UPce/TnzesCHdVQetW4fTuKdPD7dxE2lOkulDHwascPeVAGY2GxgHJAZ6k2BWcfuuvLwwbvPmcH3msoB/7jl44IEwrVOnEO5lAT9sWHpvAlsfpaXhehc1BXLiuO3bq15W69ZhX0TXruF5yJDw3KVLOLW6Zcuww7q252Tmqe9zc/sHLFImmUDvCayJGy4Cjq1ivrPN7LvAx8BUd1+TOIOZTQGmAPTq1avu1TaQ9u3DZTlHjw7D7vDxx5W7aV58MYxv0SIcNTF8eEXr3azqB1Q/LZXzlN0fsrqwXr8+1F6Vjh0rwjk7OxynXTZc9hz/ukOHzLo2tIhUqLUP3czOAca4+49jw+cDx8Z3r5hZF2Czu283s58AP3D3k2pabn360AsKwoWUVq+GXr1CV0lZK7uhbdgQrhFRFvBvvx0ut5pJWrXaM4yrey5rVeuKgiJNy96e+r8WiL9XdzYVOz8BcPd1cYP3A7+qa5G1KSiAKVPCldQAVq0Kw9A4od6pUzg5peyaH7t2wcaNoeVb1QOqn5bqedq1CwHdsaNazyLNWTKBvhDoa2Z9CEE+ATgvfgYz6+HuX8QGxwIfprRKQsu8LMzLlJSE8Y3VSo/XsmW4jrKISKaoNdDdvdTMrgBeIhy2+KC7LzWzW4BF7j4XuMrMxgKlwDfA5FQXunp13caLiDQ3TebEopyc0M2SqHfvcBiiiEhzUFMfepM5wGvmzHBYXLysrDBeRESaUKDn5YWLK/XuHXb89e4dhtPRfy4ikoma1MW58vIU4CIi1WkyLXQREamZAl1EJCIU6CIiEaFAFxGJCAW6iEhEpO3EIjMrBqo4VahJ6Qp8ne4iMoi2RwVti8q0PSrbm+3R292rvKFm2gI9CsxsUXVnbDVH2h4VtC0q0/aorKG2h7pcREQiQoEuIhIRCvS9k5/uAjKMtkcFbYvKtD0qa5DtoT50EZGIUAtdRCQiFOgiIhGhQK8HMzvYzF4zs2VmttTM/iXdNaWbmbU0s7+Z2R/TXUu6mVknM3vGzD4ysw/NbHi6a0onM5sa+zv5wMyeNLO26a6psZjZg2b2DzP7IG5cZzN72cw+iT3vn6r1KdDrpxS4xt2PBI4DLjezI9NcU7r9Cw1wL9km6r+AF929PzCQZrxdzKwncBWQ6+7fIdzGckJ6q2pUDwNjEsZNA+a7e19gfmw4JRTo9eDuX7j74tjrTYQ/2J7prSp9zCwbOAO4P921pJuZdQS+CzwA4O473H1DeqtKu1bAvmbWCsgCPk9zPY3G3d8g3Gc53jjgkdjrR4B/TtX6FOh7ycxygMHA2+mtJK3uBK4Ddqe7kAzQBygGHop1Qd1vZu3SXVS6uPtaYBawGvgC2Oju/5veqtLuAHf/Ivb6S+CAVC1Ygb4XzKw98D/A1e7+bbrrSQczOxP4h7u/m+5aMkQrYAjwG3cfDGwhhV+pm5pY//A4wj+6g4B2ZvbD9FaVOTwcN56yY8cV6PVkZq0JYV7g7s+mu540GgmMNbNCYDZwkpk9nt6S0qoIKHL3sm9szxACvrk6BfjM3YvdfSfwLDAizTWl21dm1gMg9vyPVC1YgV4PZmaEPtIP3f0/011POrn79e6e7e45hJ1dr7p7s22BufuXwBozOzw26mRgWRpLSrfVwHFmlhX7uzmZZryTOGYuMCn2ehLw+1QtWIFePyOB8wmt0SWxx+npLkoyxpVAgZm9DwwCfpHmetIm9k3lGWAx8HdC5jSbywCY2ZPAW8DhZlZkZj8CbgNONbNPCN9gbkvZ+nTqv4hINKiFLiISEQp0EZGIUKCLiESEAl1EJCIU6CIiEaFAFxGJCAW6iEhE/B9RCUfD5lycygAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_6\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_7 (Embedding)      (None, 100, 100)          1000000   \n",
      "_________________________________________________________________\n",
      "flatten_6 (Flatten)          (None, 10000)             0         \n",
      "_________________________________________________________________\n",
      "dense_10 (Dense)             (None, 32)                320032    \n",
      "_________________________________________________________________\n",
      "dense_11 (Dense)             (None, 1)                 33        \n",
      "=================================================================\n",
      "Total params: 1,320,065\n",
      "Trainable params: 1,320,065\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/akshat/Documents/GHrepos/envs/ml_env/lib/python3.7/site-packages/tensorflow_core/python/framework/indexed_slices.py:424: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
      "  \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 200 samples, validate on 10000 samples\n",
      "Epoch 1/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.6921 - acc: 0.5050 - val_loss: 0.6922 - val_acc: 0.5082\n",
      "Epoch 2/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.5329 - acc: 0.9650 - val_loss: 0.6989 - val_acc: 0.5075\n",
      "Epoch 3/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.3281 - acc: 0.9850 - val_loss: 0.7219 - val_acc: 0.5108\n",
      "Epoch 4/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.1573 - acc: 0.9900 - val_loss: 0.7048 - val_acc: 0.5194\n",
      "Epoch 5/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.0731 - acc: 1.0000 - val_loss: 0.7326 - val_acc: 0.5157\n",
      "Epoch 6/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.0383 - acc: 1.0000 - val_loss: 0.7121 - val_acc: 0.5233\n",
      "Epoch 7/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.0209 - acc: 1.0000 - val_loss: 0.7429 - val_acc: 0.5173\n",
      "Epoch 8/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.0117 - acc: 1.0000 - val_loss: 0.7510 - val_acc: 0.5186\n",
      "Epoch 9/10\n",
      "200/200 [==============================] - 1s 3ms/step - loss: 0.0070 - acc: 1.0000 - val_loss: 0.7497 - val_acc: 0.5244\n",
      "Epoch 10/10\n",
      "200/200 [==============================] - 0s 2ms/step - loss: 0.0043 - acc: 1.0000 - val_loss: 0.7620 - val_acc: 0.5236\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Embedding, Flatten, Dense\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Embedding(max_words, embedding_dim, input_length=maxlen))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(32, activation='relu'))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.summary()\n",
    "\n",
    "model.compile(optimizer='rmsprop',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['acc'])\n",
    "history = model.fit(x_train, y_train,\n",
    "                    epochs=10,\n",
    "                    batch_size=32,\n",
    "                    validation_data=(x_val, y_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8GearUAAAgAElEQVR4nO3de5gU9Z3v8feHQYQB5O6NUcAEJBrkNmIENbjqLl4OrEYTcJJI3BUvUVeeNR6NSSRm2ZNs2NX1ibohxkuUBF2zh2CicaPRYzZmI+N1xSsq6uANQQFFlMv3/FE1Mz1Nz0zP0NAzNZ/X89TT1VXVVd+unvn0r39VXa2IwMzMOr9u5S7AzMxKw4FuZpYRDnQzs4xwoJuZZYQD3cwsIxzoZmYZ4UDPMEn3SDqj1MuWk6SVko7dCesNSZ9Ox/9N0reLWbYd26mR9J/trdOsJfJ56B2LpA9y7lYCHwNb0/tnR8SiXV9VxyFpJfC3EXFfidcbwMiIWFGqZSUNB14BdouILaWo06wl3ctdgDUVEX3qx1sKL0ndHRLWUfjvsWNwl0snIWmqpDpJ/1vSW8BNkgZI+rWk1ZLeS8erch7zoKS/TcdnS/ovSQvSZV+RdHw7lx0h6SFJGyTdJ+laSbc1U3cxNX5P0h/T9f2npME5878i6VVJayRd3sL+OUzSW5IqcqadLOmpdHySpD9Jel/Sm5J+JKlHM+u6WdI/5Nz/RvqYNySdmbfsiZIel7Re0uuS5uXMfii9fV/SB5IOr9+3OY+fLGmZpHXp7eRi900b9/NASTelz+E9SUty5s2Q9ET6HF6SNC2d3qR7S9K8+tdZ0vC06+lvJL0G/D6d/u/p67Au/Rs5OOfxvST9c/p6rkv/xnpJ+o2kC/Kez1OSTi70XK15DvTOZW9gIDAMmEPy+t2U3t8f+Aj4UQuPPwx4HhgM/BPwU0lqx7I/Bx4BBgHzgK+0sM1iajwd+BqwJ9ADuBhA0kHA9en69023V0UBEfFn4EPgL/LW+/N0fCswN30+hwPHAOe1UDdpDdPSeo4DRgL5/fcfAl8F+gMnAudK+ut03lHpbf+I6BMRf8pb90DgN8A16XP7F+A3kgblPYft9k0Bre3nW0m68A5O13VVWsMk4GfAN9LncBSwsrn9UcDngc8Af5Xev4dkP+0JPAbkdhEuACYCk0n+ji8BtgG3AF+uX0jSWGAoyb6xtogIDx10IPnHOjYdnwp8AvRsYflxwHs59x8k6bIBmA2syJlXCQSwd1uWJQmLLUBlzvzbgNuKfE6FavxWzv3zgN+m498BFufM653ug2ObWfc/ADem431JwnZYM8teBPzfnPsBfDodvxn4h3T8RuD7OcuNyl22wHqvBq5Kx4eny3bPmT8b+K90/CvAI3mP/xMwu7V905b9DOxDEpwDCiz34/p6W/r7S+/Pq3+dc57bAS3U0D9dph/JG85HwNgCy/UE3iM5LgFJ8F+3q//fsjC4hd65rI6ITfV3JFVK+nH6EXY9yUf8/rndDnneqh+JiI3paJ82LrsvsDZnGsDrzRVcZI1v5YxvzKlp39x1R8SHwJrmtkXSGj9F0u7AKcBjEfFqWseotBvirbSOfyRprbemSQ3Aq3nP7zBJD6RdHeuAc4pcb/26X82b9ipJ67Rec/umiVb2834kr9l7BR66H/BSkfUW0rBvJFVI+n7abbOexpb+4HToWWhb6d/07cCXJXUDZpF8orA2cqB3LvmnJP09cCBwWETsQeNH/Oa6UUrhTWCgpMqcafu1sPyO1Phm7rrTbQ5qbuGIeIYkEI+naXcLJF03z5G0AvcAvtmeGkg+oeT6ObAU2C8i+gH/lrPe1k4he4OkiyTX/sCqIurK19J+fp3kNetf4HGvA59qZp0fknw6q7d3gWVyn+PpwAySbql+JK34+hreBTa1sK1bgBqSrrCNkdc9ZcVxoHdufUk+xr6f9sdesbM3mLZ4a4F5knpIOhz4XzupxjuBkyQdkR7AvJLW/2Z/DvwdSaD9e14d64EPJI0Gzi2yhjuA2ZIOSt9Q8uvvS9L63ZT2R5+eM281SVfHAc2s+25glKTTJXWX9CXgIODXRdaWX0fB/RwRb5L0bV+XHjzdTVJ94P8U+JqkYyR1kzQ03T8ATwAz0+WrgVOLqOFjkk9RlSSfgupr2EbSffUvkvZNW/OHp5+mSAN8G/DPuHXebg70zu1qoBdJ6+e/gd/uou3WkBxYXEPSb307yT9yIe2uMSKWA18nCek3SfpZ61p52C9IDtT9PiLezZl+MUnYbgB+ktZcTA33pM/h98CK9DbXecCVkjaQ9PnfkfPYjcB84I9Kzq75XN661wAnkbSu15AcJDwpr+5itbafvwJsJvmU8g7JMQQi4hGSg65XAeuA/0fjp4Zvk7So3wO+S9NPPIX8jOQT0irgmbSOXBcD/wMsA9YCP6BpBv0MGENyTMbawV8ssh0m6XbguYjY6Z8QLLskfRWYExFHlLuWzsotdGszSYdK+lT6EX0aSb/pktYeZ9actDvrPGBhuWvpzBzo1h57k5xS9wHJOdTnRsTjZa3IOi1Jf0VyvOFtWu/WsRa4y8XMLCPcQjczy4iyXZxr8ODBMXz48HJt3sysU3r00UffjYghheaVLdCHDx9ObW1tuTZvZtYpScr/dnEDd7mYmWWEA93MLCMc6GZmGeFANzPLCAe6mVlGtBrokm6U9I6kp5uZL0nXSFqR/mzUhNKXada6RYtg+HDo1i25XVSGn9PuCDW4ji5cR2u/gEFyGdIJwNPNzD+B5NKcAj4H/LmYX9aYOHFimJXKbbdFVFZGQONQWZlM70o1uI7s1wHURjO5WtRX/yUNB34dEZ8tMO/HwIMR8Yv0/vPA1Eiuwdys6urq8HnoVirDh8OrBc7OHTYMVq7sOjW4juzXIenRiKguNK8UfehDafoTXXU0/Qmt3ELmSKqVVLt69eoSbNos8dprbZue1RpcR9euY5ceFI2IhRFRHRHVQ4YU/OaqdUIdoX9y//wfhmtlelZrcB1du45SBPoqmv7mYhXt+01E64QWLYI5c5KPkhHJ7Zw5uz7U58+Hysqm0york+ldqQbX0cXraK5zPXcg+bHX5g6KnkjTg6KPFLNOHxTdcbfdFjFsWISU3O7qgzwRyXZzD/LUD8OG7fpaOsL+6Ag1uI5s18GOHBSV9AtgKjCY5AL0VwC7pW8G/yZJwI+AacBG4GsR0erRTh8U3TH1LeONGxunVVbCwoVQU7Pr6ujWLYnwfBJs27br6jDrKlo6KFq2H7hwoO+YrB25N7Pi7OyzXKwMOsqR+47SP2lmDvROq6Mcua+pSbp5hg1LulmGDdv13T5mlnCgd1IdqWVcU5N0r2zbltw6zM3Kw4HeSbllbGb5yvYTdLbjamoc4GbWyC30dugI34w0M8vnFnob5Z//Xf/NSHBr2czKyy30Nrr88qZf5oHk/uWXl6ceM7N6DvQ26ijnf5uZ5XOgt1FHOf/bzCyfA72NOtL532ZmuRzobeTzv82so/JZLu3g87/NrCNyC93MLCMc6GZmGeFANzPLCAe6mVlGONDNzDLCgW5mlhEOdDOzjHCgm5llhAPdzCwjHOhmZhnhQDczywgHuplZRjjQzcwywoFuZpYRDnQzs4xwoJuZZYQD3cwsIxzoZmYZUVSgS5om6XlJKyRdWmD+MEn3S3pK0oOSqkpfqpmZtaTVQJdUAVwLHA8cBMySdFDeYguAn0XEIcCVwP8pdaFmZtayYlrok4AVEfFyRHwCLAZm5C1zEPD7dPyBAvPNzGwnKybQhwKv59yvS6flehI4JR0/GegraVD+iiTNkVQrqXb16tXtqdfMzJpRqoOiFwOfl/Q48HlgFbA1f6GIWBgR1RFRPWTIkBJt2szMALoXscwqYL+c+1XptAYR8QZpC11SH+ALEfF+qYo0M7PWFdNCXwaMlDRCUg9gJrA0dwFJgyXVr+sy4MbSlmlmZq1pNdAjYgtwPnAv8CxwR0Qsl3SlpOnpYlOB5yW9AOwFzN9J9ZqZWTMUEWXZcHV1ddTW1pZl22ZmnZWkRyOiutA8f1PUzCwjHOhmZhnhQDczywgHuplZRjjQzcwywoFuZpYRDnQzs4xwoJuZZYQD3cwsIxzoZmYZ4UA3M8sIB7qZWUY40M3MMsKBbmaWEQ50M7OMcKCbmWWEA93MLCMc6GZmGeFANzPLCAe6mVlGONDNzDLCgW5mlhEOdDOzjHCgm5llhAPdzCwjHOhmZhnhQDczywgHuplZRjjQzcwywoFuZpYRDnQzs4woKtAlTZP0vKQVki4tMH9/SQ9IelzSU5JOKH2pZmbWklYDXVIFcC1wPHAQMEvSQXmLfQu4IyLGAzOB60pdqJmZtayYFvokYEVEvBwRnwCLgRl5ywSwRzreD3ijdCWamVkxign0ocDrOffr0mm55gFfllQH3A1cUGhFkuZIqpVUu3r16naUa2ZmzSnVQdFZwM0RUQWcANwqabt1R8TCiKiOiOohQ4aUaNNmZgbFBfoqYL+c+1XptFx/A9wBEBF/AnoCg0tRoJmZFad7EcssA0ZKGkES5DOB0/OWeQ04BrhZ0mdIAt19KmYd1ObNm6mrq2PTpk3lLsWa0bNnT6qqqthtt92KfkyrgR4RWySdD9wLVAA3RsRySVcCtRGxFPh74CeS5pIcIJ0dEdGuZ2FmO11dXR19+/Zl+PDhSCp3OZYnIlizZg11dXWMGDGi6McV00InIu4mOdiZO+07OePPAFOK3qqZldWmTZsc5h2YJAYNGkRbTx7xN0XNuiiHecfWntfHgW5mu9yaNWsYN24c48aNY++992bo0KEN9z/55JMWH1tbW8uFF17Y6jYmT55cqnI7jaK6XMysa1u0CC6/HF57DfbfH+bPh5qa9q9v0KBBPPHEEwDMmzePPn36cPHFFzfM37JlC927F46n6upqqqurW93Gww8/3P4COym30M2sRYsWwZw58OqrEJHczpmTTC+l2bNnc84553DYYYdxySWX8Mgjj3D44Yczfvx4Jk+ezPPPPw/Agw8+yEknnQQkbwZnnnkmU6dO5YADDuCaa65pWF+fPn0alp86dSqnnnoqo0ePpqamhvpzNu6++25Gjx7NxIkTufDCCxvWm2vlypUceeSRTJgwgQkTJjR5o/jBD37AmDFjGDt2LJdemlzmasWKFRx77LGMHTuWCRMm8NJLL5V2R7XALXQza9Hll8PGjU2nbdyYTN+RVnohdXV1PPzww1RUVLB+/Xr+8Ic/0L17d+677z6++c1v8stf/nK7xzz33HM88MADbNiwgQMPPJBzzz13u1P9Hn/8cZYvX86+++7LlClT+OMf/0h1dTVnn302Dz30ECNGjGDWrFkFa9pzzz353e9+R8+ePXnxxReZNWsWtbW13HPPPfzqV7/iz3/+M5WVlaxduxaAmpoaLr30Uk4++WQ2bdrEtm3bSruTWuBAN7MWvfZa26bviNNOO42KigoA1q1bxxlnnMGLL76IJDZv3lzwMSeeeCK77747u+++O3vuuSdvv/02VVVVTZaZNGlSw7Rx48axcuVK+vTpwwEHHNBwWuCsWbNYuHDhduvfvHkz559/Pk888QQVFRW88MILANx333187Wtfo7KyEoCBAweyYcMGVq1axcknnwwk55LvSu5yMbMW7b9/26bviN69ezeMf/vb3+boo4/m6aef5q677mr2S1C77757w3hFRQVbtmxp1zLNueqqq9hrr7148sknqa2tbfWgbTk50M2sRfPnQ9oIbVBZmUzfmdatW8fQocl1AG+++eaSr//AAw/k5ZdfZuXKlQDcfvvtzdaxzz770K1bN2699Va2bt0KwHHHHcdNN93ExrQ/au3atfTt25eqqiqWLFkCwMcff9wwf1dwoJtZi2pqYOFCGDYMpOR24cLS95/nu+SSS7jssssYP358m1rUxerVqxfXXXcd06ZNY+LEifTt25d+/fptt9x5553HLbfcwtixY3nuuecaPkVMmzaN6dOnU11dzbhx41iwYAEAt956K9dccw2HHHIIkydP5q233ip57c1Rub6hX11dHbW1tWXZtllX9+yzz/KZz3ym3GWU3QcffECfPn2ICL7+9a8zcuRI5s6dW+6yGhR6nSQ9GhEFz9t0C93Muqyf/OQnjBs3joMPPph169Zx9tlnl7ukHeKzXMysy5o7d26HapHvKLfQzcwywoFuZpYRDnQzs4xwoJuZZYQD3cx2uaOPPpp77723ybSrr76ac889t9nHTJ06lfpTnU844QTef//97ZaZN29ew/ngzVmyZAnPPPNMw/3vfOc73HfffW0pv8NyoJvZLjdr1iwWL17cZNrixYubvUBWvrvvvpv+/fu3a9v5gX7llVdy7LHHtmtdHY0D3cx2uVNPPZXf/OY3DddFWblyJW+88QZHHnkk5557LtXV1Rx88MFcccUVBR8/fPhw3n33XQDmz5/PqFGjOOKIIxousQvJOeaHHnooY8eO5Qtf+AIbN27k4YcfZunSpXzjG99g3LhxvPTSS8yePZs777wTgPvvv5/x48czZswYzjzzTD7++OOG7V1xxRVMmDCBMWPG8Nxzz21XU0e4zK7PQzfr4i66CNLfmiiZcePg6qubnz9w4EAmTZrEPffcw4wZM1i8eDFf/OIXkcT8+fMZOHAgW7du5ZhjjuGpp57ikEMOKbieRx99lMWLF/PEE0+wZcsWJkyYwMSJEwE45ZRTOOusswD41re+xU9/+lMuuOACpk+fzkknncSpp57aZF2bNm1i9uzZ3H///YwaNYqvfvWrXH/99Vx00UUADB48mMcee4zrrruOBQsWcMMNNzR5fEe4zK5b6GZWFrndLrndLXfccQcTJkxg/PjxLF++vEn3SL4//OEPnHzyyVRWVrLHHnswffr0hnlPP/00Rx55JGPGjGHRokUsX768xXqef/55RowYwahRowA444wzeOihhxrmn3LKKQBMnDix4YJeuTZv3sxZZ53FmDFjOO200xrqLvYyu5X5V0BrB7fQzbq4llrSO9OMGTOYO3cujz32GBs3bmTixIm88sorLFiwgGXLljFgwABmz57d7GVzWzN79myWLFnC2LFjufnmm3nwwQd3qN76S/A2d/nd3Mvsbtu2bZdfCx3cQjezMunTpw9HH300Z555ZkPrfP369fTu3Zt+/frx9ttvc88997S4jqOOOoolS5bw0UcfsWHDBu66666GeRs2bGCfffZh8+bNLMr5vby+ffuyYcOG7dZ14IEHsnLlSlasWAEkV038/Oc/X/Tz6QiX2XWgm1nZzJo1iyeffLIh0MeOHcv48eMZPXo0p59+OlOmTGnx8RMmTOBLX/oSY8eO5fjjj+fQQw9tmPe9732Pww47jClTpjB69OiG6TNnzuSHP/wh48ePb3IgsmfPntx0002cdtppjBkzhm7dunHOOecU/Vw6wmV2fflcsy7Il8/tHHz5XDOzLsqBbmaWEQ50M7OMcKCbdVHlOn5mxWnP6+NAN+uCevbsyZo1axzqHVREsGbNmjafy+4vFpl1QVVVVdTV1bF69epyl2LN6NmzJ1VVVW16TFGBLmka8K9ABXBDRHw/b/5VwNHp3Upgz4ho36XQzGyn22233RgxYkS5y7ASazXQJVUA1wLHAXXAMklLI6LhAgsRMTdn+QuA8TuhVjMza0ExfeiTgBUR8XJEfAIsBma0sPws4BelKM7MzIpXTKAPBV7PuV+XTtuOpGHACOD3zcyfI6lWUq377szMSqvUZ7nMBO6MiK2FZkbEwoiojojqIUOGlHjTZmZdWzGBvgrYL+d+VTqtkJm4u8XMrCyKCfRlwEhJIyT1IAntpfkLSRoNDAD+VNoSzcysGK0GekRsAc4H7gWeBe6IiOWSrpQ0PWfRmcDi8DcVzMzKoqjz0CPibuDuvGnfybs/r3RlmZlZW/mr/2ZmGeFANzPLCAe6mVlGONDNzDLCgW5mlhEOdDOzjHCgm5llhAPdzCwjHOhmZhnhQDczywgHuplZRjjQzcwywoFuZpYRDnQzs4xwoJuZZYQD3cwsIxzoZmYZ4UA3M8sIB7qZWUY40M3MMsKBbmaWEQ50M7OMcKCbmWWEA93MLCMc6GZmGeFANzPLCAe6mVlGONDNzDLCgW5mlhEOdDOzjHCgm5llRFGBLmmapOclrZB0aTPLfFHSM5KWS/p5acs0M7PWdG9tAUkVwLXAcUAdsEzS0oh4JmeZkcBlwJSIeE/SnjurYDMzK6yYFvokYEVEvBwRnwCLgRl5y5wFXBsR7wFExDulLdPMzFpTTKAPBV7PuV+XTss1Chgl6Y+S/lvStEIrkjRHUq2k2tWrV7evYjMzK6hUB0W7AyOBqcAs4CeS+ucvFBELI6I6IqqHDBlSok2bmRkUF+irgP1y7lel03LVAUsjYnNEvAK8QBLwZma2ixQT6MuAkZJGSOoBzASW5i2zhKR1jqTBJF0wL5ewTjMza0WrgR4RW4DzgXuBZ4E7ImK5pCslTU8XuxdYI+kZ4AHgGxGxZmcVbWZm21NElGXD1dXVUVtbW5Ztm5l1VpIejYjqQvP8TVEzs4xwoJuZZYQD3cwsIxzoZmYZ4UA3M8sIB7qZWUY40M3MMsKBbmaWEQ50M7OMcKCbmWWEA93MLCMc6GZmGeFANzPLCAe6mVlGONDNzDLCgW5mlhEOdDOzjHCgm5llhAPdzCwjHOhmZhnhQDczywgHuplZRjjQzcwyonu5CzDLkgh4/31Ytw769UuGbm427RKbNyf7fu3aZHjvve1vt2xJXo+KisK3pZzX0vKjR0NVVen3gQPdrBXbtsGaNfD224WHd95pOv7JJ42PlWDAABg4sHEYNKjp/ULT+/dP/vm7mghYv75wGLd2u2FDy+vu2xd69ICtW5PXtP42f3xXuP56OOec0q/XgW5tUv8P98YbTYc330xaHr17J0OfPo3juUP+9N13T0JvV9uyBd59t/mQzh1Wr07+4fPtthvstVfjcMghjeP9+iWt9PrWYv2wZg288EIy/v77LdfYv3/rbwL58wYMgO4l/K+OSJ77li2Nt+0ZPvyw9VCu3yeF9nW9Hj2aPvf99oOxYxvfNJu77d+/uP0S0fic88O+pTeCti7z6U+X7jXK5UC3Bh9+uH1QFxo2btz+sX36NK4jovht1r8JFPsG0Nr0nj2TYGgpoN95JwnzQnX27NkYyvvvD4ce2jS0c4f+/XfszWjr1qZdBPWBn/8mUD+89FJjALa0j/fYozHwevfesUBuKVzbS2p8s6oP3BEjWg/lAQOgV6+d2wCQkqGzdpM50LuATZuSFnRrQb1+/faP7dULhg6FffeF6urkNn/YZ5/GQI9ItvfBB0m45w5tmbZ+fVJz7rRCbyTF6N27MYRHjoQjjmg+pPv23XWfGCoqktb1oEFte9y2bdu3/pt7I/jww+RTUPfuyVBR0The7NCex+Q/rrKyMZR9XGHncaB3Qps3J+FWP7z7bstBvXbt9uvo0aMxkD/7WfjLvywc1nvs0baAk5I3gV69YMiQ0j1nSILso49afjP46KMkOHJDunfv0tZRbt26JcE4YAB86lPlrsY6kk4V6IsWwWWXweuvJ63Gyy6D005rPKKcP+Qebe7Wbee3vOoDJzdsd8awZUvzNVRUJC3mffdN+umOOqpwUA8cWJ6+6x2R20dvZttTtKXDs4Sqq6ujtra26OUXLYI5c9r/sbtea6FfzBtD/bB1a9MA37SpffVUVrZ/6NUr+cheH9SDB3fNsyPMugpJj0ZEdaF5RbXQJU0D/hWoAG6IiO/nzZ8N/BBYlU76UUTc0O6KC7j88sJhPnAgfPe7jUeUC52G1Nywo8vsaBhXViZdH52tpWxmHVOrgS6pArgWOA6oA5ZJWhoRz+QtentEnL8TagTgtdcKT3/vPTh/p23VzKzzKOZY8yRgRUS8HBGfAIuBGTu3rO3tv3/bppuZdTXFBPpQ4PWc+3XptHxfkPSUpDsl7VdoRZLmSKqVVLt69eo2FTp/ftJFkauyMpluZmaluzjXXcDwiDgE+B1wS6GFImJhRFRHRPWQNp7TVlMDCxfCsGFJn/OwYcn9mpodL97MLAuKOSi6CshtcVfRePATgIhYk3P3BuCfdry07dXUOMDNzJpTTAt9GTBS0ghJPYCZwNLcBSTtk3N3OvBs6Uo0M7NitNpCj4gtks4H7iU5bfHGiFgu6UqgNiKWAhdKmg5sAdYCs3dizWZmVkCn+WKRmZm1/MUiXyLHzCwjHOhmZhlRti4XSauBV8uy8dIZDLxb7iI6EO+PRt4XTXl/NLUj+2NYRBQ877tsgZ4Fkmqb68vqirw/GnlfNOX90dTO2h/ucjEzywgHuplZRjjQd8zCchfQwXh/NPK+aMr7o6mdsj/ch25mlhFuoZuZZYQD3cwsIxzo7SBpP0kPSHpG0nJJf1fumspNUoWkxyX9uty1lJuk/unvAjwn6VlJh5e7pnKSNDf9P3la0i8k9Sx3TbuKpBslvSPp6ZxpAyX9TtKL6e2AUm3Pgd4+W4C/j4iDgM8BX5d0UJlrKre/w1fZrPevwG8jYjQwli68XyQNBS4EqiPisyQX+JtZ3qp2qZuBaXnTLgXuj4iRwP3p/ZJwoLdDRLwZEY+l4xtI/mEL/YpTlyCpCjiR5Fr4XZqkfsBRwE8BIuKTiHi/vFWVXXegl6TuQCXwRpnr2WUi4iGSK9DmmkHjjwDdAvx1qbbnQN9BkoYD44E/l7eSsroauATYVu5COoARwGrgprQL6gZJvctdVLlExCpgAfAa8CawLiL+s7xVld1eEfFmOv4WsFepVuxA3wGS+gC/BC6KiPXlrqccJJ0EvBMRj5a7lg6iOzABuD4ixgMfUsKP1J1N2j88g+SNbl+gt6Qvl7eqjiOS88ZLdu64A72dJO1GEuaLIuI/yl1PGU0BpktaCSwG/kLSbeUtqazqgLqIqP/EdidJwHdVxwKvRMTqiNgM/Acwucw1ldvb9b/ylt6+U6oVO9DbQZJI+kifjYh/KXc95RQRl0VEVUQMJznY9fuI6LItsIh4C3hd0oHppGOAZ8pYUrm9BnxOUmX6f3MMXfggcWopcEY6fgbwq4OuElcAAAB9SURBVFKt2IHePlOAr5C0Rp9IhxPKXZR1GBcAiyQ9BYwD/rHM9ZRN+knlTuAx4H9IMqfLXAZA0i+APwEHSqqT9DfA94HjJL1I8gnm+yXbnr/6b2aWDW6hm5llhAPdzCwjHOhmZhnhQDczywgHuplZRjjQzcwywoFuZpYR/x8tdoA/qv4lxAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure()\n",
    "\n",
    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dir = os.path.join(imdb_dir, 'test')\n",
    "\n",
    "labels = []\n",
    "texts = []\n",
    "\n",
    "for label_type in ['neg', 'pos']:\n",
    "    dir_name = os.path.join(test_dir, label_type)\n",
    "    for fname in sorted(os.listdir(dir_name)):\n",
    "        if fname[-4:] == '.txt':\n",
    "            f = open(os.path.join(dir_name, fname))\n",
    "            texts.append(f.read())\n",
    "            f.close()\n",
    "            if label_type == 'neg':\n",
    "                labels.append(0)\n",
    "            else:\n",
    "                labels.append(1)\n",
    "\n",
    "sequences = tokenizer.texts_to_sequences(texts)\n",
    "x_test = pad_sequences(sequences, maxlen=maxlen)\n",
    "y_test = np.asarray(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25000/25000 [==============================] - 1s 38us/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.8279456302833557, 0.5571600198745728]"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.load_weights('datasets/pre_trained_glove_model.h5')\n",
    "model.evaluate(x_test, y_test)"
   ]
  },
  {
   "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
}