2_Keras_for_Sentiment_Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's classify IMBD movie reviews into positive and negative interviews using LSTMs in Keras.\n",
    "# We are using Tensorflow 1.5 as backend, and Keras 2.1.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from keras.layers import LSTM, Embedding\n",
    "from keras.datasets import imdb\n",
    "from keras.preprocessing import sequence\n",
    "from keras.models import Sequential, Model\n",
    "from keras.layers import Dense, Dropout, Activation, Input, Bidirectional\n",
    "from keras.callbacks import EarlyStopping\n",
    "from keras.callbacks import Callback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1.3\n"
     ]
    }
   ],
   "source": [
    "import keras\n",
    "print(keras.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data...\n",
      "25000 train sequences\n",
      "25000 test sequences\n"
     ]
    }
   ],
   "source": [
    "print('Loading data...')\n",
    "max_words = 400\n",
    "(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_words) # , skip_top=10)\n",
    "print(len(x_train), 'train sequences')\n",
    "print(len(x_test), 'test sequences')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# monitor the loss, if the loss climbs instead of going down we stop the training\n",
    "early_stopping=EarlyStopping(monitor='val_loss', patience=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pad sequences (samples x time)\n",
      "x_train shape: (25000, 400)\n",
      "x_test shape: (25000, 400)\n"
     ]
    }
   ],
   "source": [
    "print('Pad sequences (samples x time)')\n",
    "maxlen = 400  # 400\n",
    "x_train = sequence.pad_sequences(x_train, maxlen=maxlen)\n",
    "x_test = sequence.pad_sequences(x_test, maxlen=maxlen)\n",
    "print('x_train shape:', x_train.shape)\n",
    "print('x_test shape:', x_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Build model...\n"
     ]
    }
   ],
   "source": [
    "batch_size = 124\n",
    "epochs = 1  # let's train for only one epoch to save time\n",
    "\n",
    "print('Build model...')\n",
    "model = Sequential()\n",
    "model.add(Embedding(max_words, 50))  # 1000\n",
    "model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))\n",
    "model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2, return_sequences=True))\n",
    "model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))\n",
    "model.add(Dense(1, activation='sigmoid'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer='adam',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# track time it took for each epoch\n",
    "class TimeHistory(Callback):\n",
    "    \n",
    "    def on_train_begin(self, logs={}):\n",
    "        self.times = []\n",
    "\n",
    "    def on_epoch_begin(self, batch, logs={}):\n",
    "        self.epoch_time_start = time.time()\n",
    "\n",
    "    def on_epoch_end(self, batch, logs={}):\n",
    "        self.times.append(time.time() - self.epoch_time_start)\n",
    "        \n",
    "time_callback = TimeHistory()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 22500 samples, validate on 2500 samples\n",
      "Epoch 1/1\n",
      "22500/22500 [==============================] - 302s 13ms/step - loss: 0.5938 - acc: 0.6749 - val_loss: 0.5204 - val_acc: 0.7508\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(x_train, y_train,\n",
    "                    batch_size=batch_size,\n",
    "                    epochs=epochs,\n",
    "                    verbose=1,\n",
    "                    validation_split=0.1,\n",
    "                    # validation_data=(x_test, y_test),\n",
    "                    callbacks=[early_stopping, time_callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All epochs took: 5.04 minutes\n"
     ]
    }
   ],
   "source": [
    "times = sum(time_callback.times)\n",
    "print(\"All epochs took:\", round(times/60, 2), \"minutes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25000/25000 [==============================] - 72s 3ms/step\n",
      "Test score: 0.5084118087911605\n",
      "Test accuracy: 0.7526400011825561\n"
     ]
    }
   ],
   "source": [
    "score, acc = model.evaluate(x_test, y_test,\n",
    "                            batch_size=batch_size)\n",
    "print('Test score:', score)\n",
    "print('Test accuracy:', acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# training a good LSTM model for just 1 epoch took a really long time, next we will see how we can make the training go faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now, let's use CNNs for this task\n",
    "# the training time is considerably faster here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing import sequence\n",
    "from keras.layers import Dense, Dropout, Activation, SpatialDropout1D\n",
    "from keras.layers import Conv1D, GlobalMaxPooling1D, PReLU, LeakyReLU\n",
    "from keras.optimizers import SGD\n",
    "\n",
    "batch_size = 64\n",
    "epochs = 10\n",
    "\n",
    "max_features = 5000\n",
    "maxlen = 400  # 400\n",
    "batch_size = 64\n",
    "embedding_dims = 100\n",
    "nb_filter = 250\n",
    "filter_length = 3\n",
    "hidden_dims = 50\n",
    "nb_epoch = 4\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Embedding(max_features, embedding_dims, input_length=maxlen))\n",
    "model.add(SpatialDropout1D(rate=0.6))\n",
    "\n",
    "model.add(Conv1D(strides=1, kernel_size=5, filters=30, padding=\"valid\"))\n",
    "model.add(Dropout(0.4))\n",
    "model.add(LeakyReLU())\n",
    "\n",
    "model.add(Conv1D(strides=1, kernel_size=5, filters=30, padding=\"valid\"))\n",
    "model.add(Dropout(0.4))\n",
    "model.add(LeakyReLU())\n",
    "\n",
    "model.add(GlobalMaxPooling1D())\n",
    "\n",
    "model.add(Dense(250))\n",
    "model.add(Dropout(0.5))\n",
    "model.add(LeakyReLU())\n",
    "\n",
    "model.add(Dense(1))\n",
    "model.add(Activation('sigmoid'))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer='adam',\n",
    "              # optimizer=SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True),  # 'adam'\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 22500 samples, validate on 2500 samples\n",
      "Epoch 1/10\n",
      "22500/22500 [==============================] - 5s 213us/step - loss: 0.6326 - acc: 0.6074 - val_loss: 0.5253 - val_acc: 0.7692\n",
      "Epoch 2/10\n",
      "22500/22500 [==============================] - 4s 158us/step - loss: 0.4858 - acc: 0.7657 - val_loss: 0.4849 - val_acc: 0.7876\n",
      "Epoch 3/10\n",
      "22500/22500 [==============================] - 4s 164us/step - loss: 0.4533 - acc: 0.7874 - val_loss: 0.4593 - val_acc: 0.8016\n",
      "Epoch 4/10\n",
      "22500/22500 [==============================] - 3s 155us/step - loss: 0.4370 - acc: 0.7990 - val_loss: 0.4490 - val_acc: 0.8080\n",
      "Epoch 5/10\n",
      "22500/22500 [==============================] - 3s 154us/step - loss: 0.4296 - acc: 0.8005 - val_loss: 0.4443 - val_acc: 0.8136\n",
      "Epoch 6/10\n",
      "22500/22500 [==============================] - 3s 155us/step - loss: 0.4179 - acc: 0.8079 - val_loss: 0.4422 - val_acc: 0.8100\n",
      "Epoch 7/10\n",
      "22500/22500 [==============================] - 3s 155us/step - loss: 0.4142 - acc: 0.8111 - val_loss: 0.4293 - val_acc: 0.8144\n",
      "Epoch 8/10\n",
      "22500/22500 [==============================] - 4s 160us/step - loss: 0.4092 - acc: 0.8128 - val_loss: 0.4305 - val_acc: 0.8168\n",
      "Epoch 9/10\n",
      "22500/22500 [==============================] - 4s 163us/step - loss: 0.4034 - acc: 0.8151 - val_loss: 0.4310 - val_acc: 0.8120\n",
      "Epoch 10/10\n",
      "22500/22500 [==============================] - 3s 154us/step - loss: 0.3984 - acc: 0.8193 - val_loss: 0.4338 - val_acc: 0.8152\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(x_train, y_train,\n",
    "                    batch_size=batch_size,\n",
    "                    epochs=epochs,\n",
    "                    verbose=1,\n",
    "                    validation_split=0.1,\n",
    "                    # validation_data=(x_test, y_test),\n",
    "                    callbacks=[early_stopping, time_callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All epochs took: 0.61 minutes\n"
     ]
    }
   ],
   "source": [
    "times = sum(time_callback.times)\n",
    "print(\"All epochs took:\", round(times/60, 2), \"minutes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x21c16f46160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3Xt8XXWd7//XJ/f7pUnbtE3SFCilbdqmIRQQFRBE0FEUGWkVFXTk6Kg4MuM5jMcRf8zRg/4cROfHcUQFRwfpYVCB8SCXo6gwoJCUUnoBWkrSpvfc09wvn98fa6fdadNkt83OyuX9fDz2Y++99lprf7Kh672/37W/32XujoiIyGgSwi5AREQmP4WFiIiMSWEhIiJjUliIiMiYFBYiIjImhYWIiIxJYSEiImNSWIiIyJgUFiIiMqaksAsYL4WFhV5WVhZ2GSIiU0pNTU2Du88ea71pExZlZWVUV1eHXYaIyJRiZnWxrKduKBERGZPCQkRExqSwEBGRMSksRERkTAoLEREZk8JCRETGpLAQEZExTZtxFiIiM8HgoNNwuIf6li72Rm5Zqcl8+PzSuL6vwkJEZBLp7O1nb0s3e1u62BMJgz1HgqGbfa1d9A34sG0qS/MUFiIiR/T3QncL9HdD9jxITA67opMy1CrYEznw72npjNwfbSU0d/YN2ybBoCgnjfl56VSU5PHuFfNYkBc8H7rlpsf/c1BYiMjE6usODvhdLcF9d+vRx2Pd93Ue3Y8lQG4x5C2E/LKo26LgPmMWmE3onxbdKhi61Y/RKshMSWRBfjoLImEwPy94HARBGnNz0khODP/0ssJCRE6OO/R1nfoBv7979P2nZEN6HqTlQVouzDojeDy0LD0PElOgtR6aa4Pb609Ax8Hj95NfBvnHhkkZ5JZActoYf6bT2TtAW3cfbV39kfu+o8+7+mjs6B3WTTRSq2DuGK2CnLQkbKxQGxyEriboOASHDwb30Y+zi+AdXxl9H6dJYSFyIu5w+AAMDkDWnCnX5XHKutugdTe07I7c1x193LonOGgN9I6+j9ScyIE9N7gvXHz8Af/Iff7wcEg8xcNSbwe07DoSIN70JgNNtfjB10nc/hQJAz1HVnWMwylzaEqdx6HEIvYlFLHb5/DmwGx29BVS251JW88AA4N+4vcDslKTmB85+K8qyWPBybQK+nuCgGs+CIcjB/+Og9DRcHwgdDaADx6/D0uEzNlQesGpfWYnQWEh0tcNTW9Aw/bg1rgdGl6Hhh3Q2x5ZySCjIOgnz54bfJPLKgruox9nzYWklFD/nFG5Bwej1l1RYRB9vytoJURLTAm6e3JL4KzLg+6dEQ/6eZCeHwTFqR7wCb7Rd/cN0tHbT2fPQHDf28/hngE6e/rp6B2go6d/+Lf87ujHabR1nUlb98Kog70zmxZK7SCldpASO0TpwEHKeg5Sai9QRdOwGnotldbcBXRkFNOTXUJ/zkLIX0hiwRmkzV5EdnYO2WnJpCQlRBcOvYcjB/p62H8QdkQO/h2Rg//hQ0cfH/s5D0lKh6zZkDkH8kphQWXwOHN2ZHnktaw5wWeeMDFdVAoLmRncg3/EDa9HwmDo9nrwbZSob5C5JVBwFlR8OPhGnJAE7fvh8P7gvn0/7N8c/KMf6dteRsExQTI3KmTmRZ4XQVLq+P+dgwPQvi8qAHYdDYKWXUHXTX/X8G1SsiGvJPi7S88P7vNKILc0uM+cc8IDkrvT0z9IR08/nb0DdLT109HTHnneT0fPwNED/bDnkfWj7qPDYYwv9EekJyeSk55ETloyOenJFGalcMbszMjzo8uPf540/GDf1z2sVZLSXMvs5lpmt9TBnhqo7Rj+xllzg+6stLxICyASCCfqYkvLCw7umbNhbvnRx0O36OepWbH98RPM3GP8rzLJVVVVua5nIfT3QNPOo0HQuCPSStgOPW1H10vOgIIzofBsKFgchELh4iAkUjJje6/BgeAg0b4v6K5q3wftB4aHSvv+4DUfOH779Pzh4XFsa2XoeXTfen9PcMCPDoHoVkHbXhjsH/4+GQXHBEDp0XDIKwkOZGYMDDpNHb00dvTQ0B7cH2rvobGjl4b2HhoO99DU0Ut7T/Q3/rG7aoYkGGSmJJGRmjjsPjM1iYyUo48zUxPJSAnuM1OOeZ6aFGybknj8N/t4cYfOxqPnR5rfjNzXBedgRjzoz4HMwuB5RuGkbm2aWY27V425nsJCppyhrpQRWwl1w7/t5ywIAqDw7KhAWBwsn6DmO4ODQZ/zUHAMhcqRkIkKlcG+47dPyw0CpbstCKJhDHLmR4XB8FZBd8Y8GvuSaWjvORIChw730Hi4l4bDPcOCoamjd8Rv9MmJRkFmKoXZKczKTCU7LYnMlKgDd9RBPzMlkYyh+5QkslKPvp6WnDD2iVyZcLGGhbqhZPLq7w2+xQ21DKLPJ0T39yalBYEwvwJW/GUkGM4KlqVmh1f/kISE4Btm1pzR1xv6xcuR8DimdZKag+cW0525gOaUIg4lzmXfYD6HOgdpGDr47+ulYXvQCmg8XEt7z44R3yozJZHC7FQKMlNYWJBB5cJ8ZmelRJalUpiVQkFWKrOzUslJj+HXOjLtKSwkfIOD0FILB7bCwa1wYEtw3/jG8O6b7HlBAJRfO7yVkFsyca2EeEpICLouMgsZmLOcNw4dZlN9K680t7C5qY19LV00dPTS2z8I9AH1kVsgPyOZwqxUCrNSKV+QG3mccmRZQdTj9JTEsP5KmaIUFjKxOpuCMDiwBQ5uiQTENuiLOoGYXwZzlsPS90LhkkgrYTGk5YRWdjwNDjq1jR28sqc1CIf6VjbvbaWzNwjKjJREls/P4cIzC48c/KMP/IVZKczKTCFpEgzckulLYSHx0dcNDa8FYXBgc6TFsHV4n3v6LJi7HFZfH9zPXQ6zz5m0vwYZD+7O7qYuNu1p4ZX6IBw272mlvSc4KZ2alMDy+Tl8qKqEFQtyWVmcyxmzs0hMUDeQhEthIadncDA4qTwUBkPBEN2FlJgKs5fAmZfCnGVHgyFr7oRPxzCR3J19rd1Ba2FPS+S+lZbIKN/kRGPpvBzeVzGfVcV5rCjOZfGcLLUQZFJSWEjshrqQDkZC4cBWOPRqMBBpyFAX0rKrI8FQHkzXcBqDtKaKg21BMGza08or9S28sqeVhsPBSOfEBGPJ3GyuXF7EiuJcVi7I4+yiLFKTdO5Apoa4/gs2syuB7wKJwI/c/Y5jXi8F/hXIi6xzq7s/Fnnt74FPAgPAze7+RDxrlSjRXUgHI+cXTtSFVPERmLssCIg550yOXx9NgMbDPbyyJzi/sClyv78tGJCVYHDWnCwuPnsOK4uDrqSl83JIS1YwyNQVt7Aws0TgbuCdBD/ZeNHMHnX3rVGrfQV40N2/b2bLgMeAssjjtcByYD7wf83sbPeRRjbJuOjvhdd/Axt+Bm/8bpQupEgwZBdN6y6kaK2dfWze28rL9UfPM+xpOToK+ozZmVxwxixWFOexsjiXZfNyyEyd/i0pmVni+X/0GmCHu+8EMLP1wNVAdFg4MPQTl1xgb+Tx1cB6d+8B3jSzHZH9PR/Hememg9uCgNi0Philmj0fLvxrmF8ZtBxmnTklupCG5hPq7O2nq2+Art4BOnsHRnjcf4LlAyfctrHj6KR5pbMyqCjN42MXLmRlcR7LF+SQkzZDJhiUGS2eR4EFwO6o5/XA+ces8zXgSTP7PJAJXB617Z+O2XbBsW9gZjcBNwGUlsb3KlHTSncbbPllEBJ7qiEhGZZcBZUfgzPfAQnhdpe0dvXxu1cP8Oq+djojB+7uvuBgfvTxwLDHXX0n3+hMTUogIyWR9ORE0iMjjtOTE8nLSGF+3tHl8/PSWVmcy4oFueRlTN5pG0TiKZ5hMVIfxbGTCawDfuLu/2RmFwI/M7PyGLfF3e8B7oFguo/TrHd6c4ddzwcBsfXh4CIys8+BK74Oq9YGg8FCdLC9m6e2HuDxzft5/o1G+gedlMQEMlITyYgctNNTEslITjruYH70gJ90zMH/+CAYWp6WnKifo4qchHiGRT1QEvW8mKPdTEM+CVwJ4O7Pm1kaUBjjthKL9gPw8s/hpX8LJtVLyQqmxFj9USiuCvW8w+6mTp7Ysp8ntuynuq4Zd1hYkMEn37aIK5cXsao4jwQd0EUmhXiGxYvAYjNbBOwhOGH94WPW2QVcBvzEzJYCacAh4FHg52Z2J8EJ7sXAC3GsdXoZ6IPtTwYB8foTwcnq0gvhrbfA8vfHPqtqHOw42M7jm/fz+Jb9bN4TzAJ7TlE2X7hsMVeWF7FkbrbmIRKZhOIWFu7eb2afA54g+Fnsve6+xcxuB6rd/VHgb4EfmtkXCbqZbvBgGtwtZvYgwcnwfuCz+iVUDBq2w0s/g5fXBxPPZc6Bt3wuaEUULg6lJHfnlT2tRwJi56FgWo/K0jy+/O5zeNfyIhYWhBdeIhIbTVE+1fV2wJaHg5DY9XxwmcWz3xUExOJ3hnIp0IFBp7q2ice37OfJLQfY09JFYoJxwRmzuHJ5Ee9cVkRR7ujXPxaRiaEpyqczd6ivhpd+Cpt/GYygLjgLLv8arFoXjIGYYL39gzz3RgNPRAKisaOXlKQE3r64kL+5fDGXL51LfqZ+SSQyVSksppKOhqCL6aWfBdNsJGfA8g8EE/GVXjjhJ6s7e/v54+uHeHzzfn677SDtPf1kpiRy6TlzuLK8iEuWzCFLg9NEpgX9S57sBgdgx2+DgHjtN8GV1BZUwXu/C8uvmfBpu1s7+/jtq8FPXP+4/RDdfYPkZyRz1Yoiriwv4i1nFmpaC5FpSGExWTW9GfyaaePPoX1vcB3lNTdB5UdhztIJLWWkMRBFOWlcV1XCu8qLWFM2SzOlikxzCovJpK8Ltv0HbPgp1D4DGJx1GVz5P2HJuyf0ou8jjYEo0xgIkRlLYTEZdLfCn74Pf/pfweO8hXDpV6BiHeQWT1gZ7s5/bNrHD/7wBlv2BmMgls7L4W8uO5sry4s4e26WxkCIzFAKizB1t8GffwDP/3MQEuf8RdDVVPa2Cb+m9OsH2rntkS08v7ORc4qyNQZCRIZRWISh5zC8cA889z3oag66mC65FeatmvBS2rv7+O7/3c5PnqslMzWJr3+gnLXnlWreJBEZRmExkXo74cUfwX/eFUwHvviKICQWnDvhpbg7j2zcyzce28ahwz2sPa+EL73rHGZpLISIjEBhMRH6uqD6Pnj2O9BxMJgG/JIvQ8l5oZTz6v42vvrIFl54s4mVxbnc87EqKkryQqlFRKYGhUU89XUHv2x65p+CS5Iuejtc8lNYeGEo5bR193HXU9v51+dryU5L4hsfWMF155Woy0lExqSwiIf+nmAQ3TN3QtseWHgRXPtjKHtrKOW4Ow9v3MPX/8+rNHb0sG5NKV+6Yomm3xCRmCksxtNAH2y8H/74bWjdDSXnw/v/Fyy6OLTrRmzb18Ztj2zhhdomVpXkce8NVawsVpeTiJwchcV4GOgPrmH9h29BS93R6TjOfEdoIdHa1cd3nnqdn/2pjtz0ZL75wRX85bklGkgnIqdEYXE6BgfglX+HP3wTmnbCvAp497eDqcFDConBQeeXL+3hjt9so7Gjl+vPX8jfXnG2rh0tIqdFYXEqBgdgy6/g93dA43aYuwLWPgBLrgr1MqVb9rby1Ue2UFPXzOrSPH5y4xrKF+SGVo+ITB8Ki5MxOAjbHglC4tCrMGcZfOhnwcjrCR5xHa21q487n3yNn/2pjvyMFL517UqurSxWl5OIjBuFRSzc4dVfw9P/Ew5ugcIlcO19sOz9oYbE4KDz0IZ6vvmbV2nu7OWjFyzklncuITdj4q+OJyLTm8JiNO7w+uPw9Ddg/6bganQf/HFwwaGEcK/ZsHlPK//wyGZe2tVC1cJ8fnr1GpbPV5eTiMSHwmIk7rD9Kfj9N2DvS5C/CD7wAyi/FhLD/chaOnv59pOvcf+fd1GQmcI//eUqrqlcoNlgRSSuFBbR3OGN3wUtiT3VkFcKV98NK9eGHhKDg86D1bv51hOv0dLZy8cvLOOL7zyb3HR1OYlI/CksIAiJN/8YhMTuP0FuSTBOYtWHJ/SCQyeyqb6Ff3hkCy/vbuG8snxuv/p8ls6b2MupisjMprBorYdf/heoexay58N7/glWfxSSUsOujOaOXv7fJ1/jgRd2UZiVyneuW8X7K9TlJCITT2GRUQB9HXDVt6Dy45CcFnZFDA46/7t6N998/FXau/v5xEWL+JvLF5Odpi4nEQmHwiI5HT71dKiD6aK9vLuFrz6ymZfrW1mzaBb/eHU5S4qywy5LRGY4hQVMiqDoGxjkq49sYf2Lu5idlcp311bwvlXz1eUkIpOCwmKSeHLLAR54YRc3vKWMv73ibHU5icikorCYJF6sbSI9OZH//p6lJCeGNypcRGQkOipNEjV1zawqyVVQiMikpCPTJNDZ28/WfW1ULZwVdikiIiNSWEwCG3e3MDDonLswP+xSRERGpLCYBDbUNQNQWaqwEJHJSWExCVTXNXP23CxNLS4ik5bCImSDg86GumZ1QYnIpKawCNmOQ4dp6+7nXJ3cFpFJTGERsura4HxFlVoWIjKJKSxCVl3XREFmCgsLMsIuRUTkhOIaFmZ2pZm9ZmY7zOzWEV7/jpltjNxeN7OWqNcGol57NJ51hmnofIXmgBKRySxu032YWSJwN/BOoB540cwedfetQ+u4+xej1v88sDpqF13uXhGv+iaDQ+091DZ28uHzS8MuRURkVPFsWawBdrj7TnfvBdYDV4+y/jrggTjWM+nURMZX6JdQIjLZxTMsFgC7o57XR5Ydx8wWAouA30UtTjOzajP7k5m9P35lhmfDrmZSEhMoX5AbdikiIqOK56yzI3XC+wnWXQs85O4DUctK3X2vmZ0B/M7MXnH3N4a9gdlNwE0ApaVTryunuraJFcW5pCYlhl2KiMio4tmyqAdKop4XA3tPsO5ajumCcve9kfudwO8Zfj5jaJ173L3K3atmz549HjVPmO6+ATbvadNPZkVkSohnWLwILDazRWaWQhAIx/2qycyWAPnA81HL8s0sNfK4ELgI2HrstlPZ5j2t9A4M6nyFiEwJceuGcvd+M/sc8ASQCNzr7lvM7Hag2t2HgmMdsN7do7uolgI/MLNBgkC7I/pXVNNB9dDkgQoLEZkC4nqlPHd/DHjsmGVfPeb510bY7jlgRTxrC1tNXTOLCjMpzEoNuxQRkTFpBHcI3DV5oIhMLQqLELzZ0EFjR6/CQkSmDIVFCIYG4+mXUCIyVSgsQlBT10xuejJnzs4KuxQRkZgoLEJQXddMZWkeCQmaPFBEpgaFxQRr6exlx8HDVJXpYkciMnUoLCbYhl2R8RWlOl8hIlOHwmKCVdc2k5RgVJTkhV2KiEjMxgwLM/ucmelr8DipqWtm+fwc0lM0eaCITB2xtCyKCC5c9GDkync6K3uK+gYGebm+RVN8iMiUM2ZYuPtXgMXAj4EbgO1m9g0zOzPOtU07W/e20d03SNVCndwWkaklpnMWkUn+9kdu/QSzxD5kZt+KY23TztDkgVVlalmIyNQy5kSCZnYz8HGgAfgR8CV37zOzBGA78F/jW+L0UVPXxIK8dObmpIVdiojISYll1tlC4Bp3r4te6O6DZvYX8Slr+nF3auqaueCMgrBLERE5abF0Qz0GNA09MbNsMzsfwN23xauw6aa+uYsDbT2aD0pEpqRYwuL7wOGo5x2RZXISanSxIxGZwmIJC4u+ip27DxLniyZNRzV1zWSlJnFOUU7YpYiInLRYwmKnmd1sZsmR2xeAnfEubLqprmtmdWkeiZo8UESmoFjC4tPAW4A9QD1wPnBTPIuabtq7+3htf5vmgxKRKWvM7iR3PwisnYBapq2Nu1sYdI2vEJGpK5ZxFmnAJ4HlwJEBAu7+iTjWNa1U1zaTYGjyQBGZsmLphvoZwfxQ7wL+ABQD7fEsarqpqWtmSVEO2WnJYZciInJKYgmLs9z9H4AOd/9X4D3AiviWNX0MDDov7WrW+AoRmdJiCYu+yH2LmZUDuUBZ3CqaZl7d30ZH7wDnKixEZAqLZbzEPZHrWXwFeBTIAv4hrlVNIxsig/EUFiIylY0aFpHJAtvcvRn4I3DGhFQ1jVTXNTM3J5Xi/PSwSxEROWWjdkNFRmt/boJqmZaqa5s5d2E+umaUiExlsZyzeMrM/s7MSsxs1tAt7pVNA/tbu9nT0sW5utiRiExxsZyzGBpP8dmoZY66pMY0NHmgfgklIlNdLCO4F01EIdNRdV0TackJLJuvyQNFZGqLZQT3x0Za7u4/Hf9yppcNdc2sKs4jOTGmq9eKiExasXRDnRf1OA24DNgAKCxG0dU7wJa9bdz0dvXWicjUF0s31Oejn5tZLsEUIDKKjbtb6B90TR4oItPCqfSPdAKLx7uQ6WbDrsiV8TQtuYhMA7Gcs/gPgl8/QRAuy4AH41nUdFBd28RZc7LIy0gJuxQRkdMWyzmLb0c97gfq3L0+TvVMC4ODzoZdLVxVXhR2KSIi4yKWsNgF7HP3bgAzSzezMnevjWtlU9gbhw7T2tWn+aBEZNqI5ZzFvwODUc8HIsvkBKo1eaCITDOxhEWSu/cOPYk8jqkj3syuNLPXzGyHmd06wuvfMbONkdvrZtYS9drHzWx75PbxWN5vsqipa6YgM4VFhZlhlyIiMi5i6YY6ZGbvc/dHAczsaqBhrI3MLBG4G3gnUA+8aGaPuvvWoXXc/YtR638eWB15PAu4DagiOLleE9m2Oea/LEQ1dc1UavJAEZlGYmlZfBr4spntMrNdwH8D/ksM260Bdrj7zkhrZD1w9SjrrwMeiDx+F/CUuzdFAuIp4MoY3jN0DYd7eLOhQ11QIjKtxDIo7w3gAjPLAszdY73+9gJgd9TzeuD8kVY0s4XAIuB3o2y7IMb3DdUGTR4oItPQmC0LM/uGmeW5+2F3bzezfDP7HzHse6Q+GB9hGcBa4CF3HziZbc3sJjOrNrPqQ4cOxVBS/NXUNZOSmED5gtywSxERGTexdENd5e5HTjxHuoXeHcN29UBJ1PNiYO8J1l3L0S6omLd193vcvcrdq2bPnh1DSfFXXddM+YIc0pITwy5FRGTcxBIWiWaWOvTEzNKB1FHWH/IisNjMFplZCkEgPHrsSma2BMgHno9a/ARwRaQVkw9cEVk2qfX0D/BKfStVZbrYkYhML7H8GurfgN+a2X2R5zcC/zrWRu7eb2afIzjIJwL3uvsWM7sdqB76dRXBie317u5R2zaZ2T8SBA7A7e7eFNufFJ7Ne1rpHRjUfFAiMu3EcoL7W2a2Cbic4FzC48DCWHbu7o8Bjx2z7KvHPP/aCba9F7g3lveZLGo0GE9EpqlYZ53dTzCK+4ME17PYFreKprDq2mbKCjKYnR1LL52IyNRxwpaFmZ1NcJ5hHdAI/G+Cn85eOkG1TSnuTk1dMxcvmRwn2kVExtNo3VCvAs8A73X3HQBm9sVR1p/R6ho7aezopWqhTm6LyPQzWjfUBwm6n542sx+a2WWMPP5BODp5oK6MJyLT0QnDwt1/5e7XAecAvwe+CMw1s++b2RUTVN+UUVPXRE5aEmfNzgq7FBGRcTfmCW5373D3+939LwgGx20EjptBdqYbmjwwIUGNLxGZfk7qGtyRif1+4O7viFdBU1FrZx+vHzis+aBEZNo6qbCQkW3YFZyvqFRYiMg0pbAYBzV1zSQmGBUleWGXIiISFwqLcVBd18Ty+TlkpMQye4qIyNSjsDhNfQODbNzdovmgRGRaU1icpm372ujuG9T4ChGZ1hQWp6m6VpMHisj0p7A4TTW7mlmQl8683PSwSxERiRuFxWlwd2pqm9WqEJFpT2FxGva0dLG/rVthISLTnsLiNOhiRyIyUygsTkNNXTOZKYmcU5QddikiInGlsDgN1bXNVJTmkZSoj1FEpjcd5U7R4Z5+Xt3fxrm62JGIzAAKi1O0cVcLg45mmhWRGUFhcYqq65owg4pSTR4oItOfwuIU1dQ1s2RuNjlpyWGXIiISdwqLUzAw6Ly0q0U/mRWRGUNhcQpeP9DO4Z5+TR4oIjOGwuIUVEcG41Xpl1AiMkMoLE5BTW0Ts7NTKc7X5IEiMjMoLE5Bza5mqhbmY2ZhlyIiMiEUFifpYFs3u5u6dHJbRGYUhcVJqtbkgSIyAyksTlJNXTOpSQksn58bdikiIhNGYXGSquuaWVWSR0qSPjoRmTl0xDsJXb0DbNnTqi4oEZlxFBYnYVN9C/2DrskDRWTGUVichKGT25WlCgsRmVkUFiehpq6ZM2dnkp+ZEnYpIiITSmERo8FBZ8OuZk3xISIzksIiRjsbDtPS2aeT2yIyI8U1LMzsSjN7zcx2mNmtJ1jnQ2a21cy2mNnPo5YPmNnGyO3ReNYZi5qhwXiaaVZEZqCkeO3YzBKBu4F3AvXAi2b2qLtvjVpnMfD3wEXu3mxmc6J20eXuFfGq72RV1zaTn5HMGYWZYZciIjLh4tmyWAPscPed7t4LrAeuPmadTwF3u3szgLsfjGM9p6WmrplzNXmgiMxQ8QyLBcDuqOf1kWXRzgbONrP/NLM/mdmVUa+lmVl1ZPn7R3oDM7spsk71oUOHxrf6KE0dvexs6OBcndwWkRkqbt1QwEhfwX2E918MXAIUA8+YWbm7twCl7r7XzM4Afmdmr7j7G8N25n4PcA9AVVXVsfseN0PnK3RlPBGZqeLZsqgHSqKeFwN7R1jnEXfvc/c3gdcIwgN33xu53wn8Hlgdx1pHVV3XRHKisWKBJg8UkZkpnmHxIrDYzBaZWQqwFjj2V00PA5cCmFkhQbfUTjPLN7PUqOUXAVsJyYa6ZsoX5JKWnBhWCSIioYpbWLh7P/A54AlgG/Cgu28xs9vN7H2R1Z4AGs1sK/A08CV3bwSWAtVm9nJk+R3Rv6KaSD39A7xc36r5oERkRovnOQvc/THgsWOWfTXqsQO3RG7R6zwHrIhnbbHavKeN3v5BDcYTkRlNI7jHsGFo8kCFhYjMYAqLMVTXNVE6K4M52WlhlyIiEhqFxSjcnZq6Fp2vEJEZT2Exil1NnTQc7tF8UCIy4yksRlFdG5k8UC0LEZnhFBaE1TCqAAAOK0lEQVSjqNnVTHZaEmfPyQ67FBGRUMX1p7NTXU1tM5Wl+SQkaPJAkYnU19dHfX093d3dYZcybaSlpVFcXExycvIpba+wOIHWrj5eP9jOe1bOC7sUkRmnvr6e7OxsysrKNNPzOHB3Ghsbqa+vZ9GiRae0D3VDncBLu5pxR7+EEglBd3c3BQUFCopxYmYUFBScVktNYXECNXXNJCYYq0rywi5FZEZSUIyv0/08FRYnUF3bzNJ52WSmqqdOZKZpbGykoqKCiooKioqKWLBgwZHnvb29Me3jxhtv5LXXXht1nbvvvpv7779/PEqOOx0JR9A/MMjG3S1cd17J2CuLyLRTUFDAxo0bAfja175GVlYWf/d3fzdsHXfH3UlIGPk793333Tfm+3z2s589/WIniFoWI9i2r52uvgGNrxCRYXbs2EF5eTmf/vSnqaysZN++fdx0001UVVWxfPlybr/99iPrvvWtb2Xjxo309/eTl5fHrbfeyqpVq7jwwgs5eDC4gvRXvvIV7rrrriPr33rrraxZs4YlS5bw3HPPAdDR0cEHP/hBVq1axbp166iqqjoSZBNJLYsRVNc1ARqMJzIZ/D//sYWte9vGdZ/L5udw23uXn9K2W7du5b777uNf/uVfALjjjjuYNWsW/f39XHrppVx77bUsW7Zs2Datra1cfPHF3HHHHdxyyy3ce++93Hrrrcft29154YUXePTRR7n99tt5/PHH+ed//meKior4xS9+wcsvv0xlZeUp1X261LIYQU1dM/Nz05iflx52KSIyyZx55pmcd955R54/8MADVFZWUllZybZt29i69fhL76Snp3PVVVcBcO6551JbWzvivq+55prj1nn22WdZu3YtAKtWrWL58lMLudOllsUIauqa1aoQmSROtQUQL5mZmUceb9++ne9+97u88MIL5OXlcf3114/489SUlJQjjxMTE+nv7x9x36mpqcetE1z2J3xqWRxjb0sX+1q7Nb5CRMbU1tZGdnY2OTk57Nu3jyeeeGLc3+Otb30rDz74IACvvPLKiC2XiaCWxTGqIxc7qiqbFXIlIjLZVVZWsmzZMsrLyznjjDO46KKLxv09Pv/5z/Oxj32MlStXUllZSXl5Obm5ueP+PmOxydLEOV1VVVVeXV192vu57ZHN/HtNPZtuu4KkRDW8RMKwbds2li5dGnYZk0J/fz/9/f2kpaWxfft2rrjiCrZv305S0sl/1x/pczWzGnevGmtbtSyOUbOrmYqSPAWFiEwKhw8f5rLLLqO/vx935wc/+MEpBcXpUlhE6ejpZ9u+dj57yZlhlyIiAkBeXh41NTVhl6ET3NE27m5hYNCp1MltEZFhFBZRauqaMUNhISJyDIVFlOq6ZpbMzSYn7dQuDiIiMl0pLCIGBp2X6prVqhARGYHCImL7wXbae/o1GE9EuOSSS44bYHfXXXfx13/91yfcJisrC4C9e/dy7bXXnnC/Y/3E/6677qKzs/PI83e/+920tLTEWnrcKCwiqmsjg/EWajCeyEy3bt061q9fP2zZ+vXrWbdu3Zjbzp8/n4ceeuiU3/vYsHjsscfIywv/ImwKi4gNdc0UZqVSMkuTB4rMdNdeey2//vWv6enpAaC2tpa9e/dSUVHBZZddRmVlJStWrOCRRx45btva2lrKy8sB6OrqYu3ataxcuZLrrruOrq6uI+t95jOfOTK1+W233QbA9773Pfbu3cull17KpZdeCkBZWRkNDQ0A3HnnnZSXl1NeXn5kavPa2lqWLl3Kpz71KZYvX84VV1wx7H3Gi8ZZRFTXNVO1MF+XchSZbH5zK+x/ZXz3WbQCrrrjhC8XFBSwZs0aHn/8ca6++mrWr1/PddddR3p6Or/61a/IycmhoaGBCy64gPe9730nPG58//vfJyMjg02bNrFp06Zh04t//etfZ9asWQwMDHDZZZexadMmbr75Zu68806efvppCgsLh+2rpqaG++67jz//+c+4O+effz4XX3wx+fn5bN++nQceeIAf/vCHfOhDH+IXv/gF119//fh8VhFqWQAH27vZ1dSpmWZF5IjorqihLih358tf/jIrV67k8ssvZ8+ePRw4cOCE+/jjH/945KC9cuVKVq5ceeS1Bx98kMrKSlavXs2WLVvGnCDw2Wef5QMf+ACZmZlkZWVxzTXX8MwzzwCwaNEiKioqgNGnQD8dalkQdEEBnFumsBCZdEZpAcTT+9//fm655RY2bNhAV1cXlZWV/OQnP+HQoUPU1NSQnJxMWVnZiFOSRxup1fHmm2/y7W9/mxdffJH8/HxuuOGGMfcz2jx+Q1ObQzC9eTy6odSyIDi5nZKUQPn8iZ/JUUQmp6ysLC655BI+8YlPHDmx3draypw5c0hOTubpp5+mrq5u1H28/e1v5/777wdg8+bNbNq0CQimNs/MzCQ3N5cDBw7wm9/85sg22dnZtLe3j7ivhx9+mM7OTjo6OvjVr37F2972tvH6c8eklgXB+YpVxbmkJCk7ReSodevWcc011xzpjvrIRz7Ce9/7XqqqqqioqOCcc84ZdfvPfOYz3HjjjaxcuZKKigrWrFkDBFe8W716NcuXLz9uavObbrqJq666innz5vH0008fWV5ZWckNN9xwZB9/9Vd/xerVq+PS5TSSGT9FeXffACu+9gSffOsZ3HrV6P/hRWRiaIry+DidKcpn/Ffptu4+riqfx9sXF469sojIDDXju6HmZKfxvXWrwy5DRGRSm/EtCxERGVtcw8LMrjSz18xsh5ndeoJ1PmRmW81si5n9PGr5x81se+T28XjWKSKTz3Q5nzpZnO7nGbduKDNLBO4G3gnUAy+a2aPuvjVqncXA3wMXuXuzmc2JLJ8F3AZUAQ7URLZtjle9IjJ5pKWl0djYSEFBgWZVGAfuTmNjI2lpaae8j3ies1gD7HD3nQBmth64Gogepvgp4O6hEHD3g5Hl7wKecvemyLZPAVcCD8SxXhGZJIqLi6mvr+fQoUNhlzJtpKWlUVxcfMrbxzMsFgC7o57XA+cfs87ZAGb2n0Ai8DV3f/wE2y6IX6kiMpkkJyezaNGisMuQKPEMi5Hajsd2miUBi4FLgGLgGTMrj3FbzOwm4CaA0tLS06lVRERGEc8T3PVASdTzYmDvCOs84u597v4m8BpBeMSyLe5+j7tXuXvV7Nmzx7V4ERE5Kp5h8SKw2MwWmVkKsBZ49Jh1HgYuBTCzQoJuqZ3AE8AVZpZvZvnAFZFlIiISgrh1Q7l7v5l9juAgnwjc6+5bzOx2oNrdH+VoKGwFBoAvuXsjgJn9I0HgANw+dLL7RGpqahrMbPRZvUZXCDScxvbTiT6L4fR5DKfP46jp8FksjGWlaTM31Okys+pY5keZCfRZDKfPYzh9HkfNpM9CI7hFRGRMCgsRERmTwuKoe8IuYBLRZzGcPo/h9HkcNWM+C52zEBGRMallISIiY5rxYRHLzLgzhZmVmNnTZrYtMgvwF8KuKWxmlmhmL5nZr8OuJWxmlmdmD5nZq5H/Ry4Mu6YwmdkXI/9ONpvZA2Z26rP0TQEzOiyiZsa9ClgGrDOzZeFWFap+4G/dfSlwAfDZGf55AHwB2BZ2EZPEd4HH3f0cYBUz+HMxswXAzUCVu5cTjCVbG25V8TWjw4KomXHdvRcYmhl3RnL3fe6+IfK4neBgMGMncDSzYuA9wI/CriVsZpYDvB34MYC797p7S7hVhS4JSDezJCCDEaYkmk5melhodtsTMLMyYDXw53ArCdVdwH8FBsMuZBI4AzgE3BfplvuRmWWGXVRY3H0P8G1gF7APaHX3J8OtKr5meljENLvtTGNmWcAvgL9x97aw6wmDmf0FcNDda8KuZZJIAiqB77v7aqADmLHn+CJz1l0NLALmA5lmdn24VcXXTA+LmGa3nUnMLJkgKO5391+GXU+ILgLeZ2a1BN2T7zCzfwu3pFDVA/XuPtTSfIggPGaqy4E33f2Qu/cBvwTeEnJNcTXTwyKWmXFnDAuuX/ljYJu73xl2PWFy979392J3LyP4/+J37j6tvzmOxt33A7vNbElk0WUMv+rlTLMLuMDMMiL/bi5jmp/wj+fFjya9E82MG3JZYboI+CjwipltjCz7srs/FmJNMnl8Hrg/8sVqJ3BjyPWExt3/bGYPARsIfkX4EtN8NLdGcIuIyJhmejeUiIjEQGEhIiJjUliIiMiYFBYiIjImhYWIiIxJYSEyBjMbMLONUbdxG7lsZmVmtnm89icSLzN6nIVIjLrcvSLsIkTCpJaFyCkys1oz+6aZvRC5nRVZvtDMfmtmmyL3pZHlc83sV2b2cuQ2ND1Eopn9MHJthCfNLD2y/s1mtjWyn/Uh/ZkigMJCJBbpx3RDXRf1Wpu7rwH+P4JZaok8/qm7rwTuB74XWf494A/uvopgXqWh2QIWA3e7+3KgBfhgZPmtwOrIfj4drz9OJBYawS0yBjM77O5ZIyyvBd7h7jsjEzDud/cCM2sA5rl7X2T5PncvNLNDQLG790Ttowx4yt0XR57/NyDZ3f+HmT0OHAYeBh5298Nx/lNFTkgtC5HT4yd4fKJ1RtIT9XiAo+cS30NwJcdzgZrIRXZEQqGwEDk910XdPx95/BxHL7H5EeDZyOPfAp+BI9f2zjnRTs0sAShx96cJLsCUBxzXuhGZKPqmIjK29KhZeCG4DvXQz2dTzezPBF+81kWW3Qzca2ZfIri63NDsrF8A7jGzTxK0ID5DcJW1kSQC/2ZmuQQX6fqOLmMqYdI5C5FTFDlnUeXuDWHXIhJv6oYSEZExqWUhIiJjUstCRETGpLAQEZExKSxERGRMCgsRERmTwkJERMaksBARkTH9/0k+BUxtUf9mAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x21c18dee828>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# inspect the model        \n",
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25000/25000 [==============================] - 1s 39us/step\n",
      "Test score: 0.4242110009765625\n",
      "Test accuracy: 0.815680000038147\n"
     ]
    }
   ],
   "source": [
    "score, acc = model.evaluate(x_test, y_test,\n",
    "                            batch_size=batch_size)\n",
    "print('Test score:', score)\n",
    "print('Test accuracy:', acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Well, using CNNs yields good results, but can't we just speed up our LSTM somehow?\n",
    "# Yes, we can use Keras' CUDA implementation of the LSTM called CuDNNLSTM, it is almost 10x faster on a GPU. \n",
    "# In this case, dropout only works in between layers. (For an advanced user: CuDNNLSTM does not support recurrent_dropout!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Build model...\n"
     ]
    }
   ],
   "source": [
    "batch_size = 124\n",
    "epochs = 10\n",
    "\n",
    "from keras.layers import CuDNNLSTM\n",
    "print('Build model...')\n",
    "model = Sequential()\n",
    "model.add(Embedding(max_words, 50))\n",
    "model.add(CuDNNLSTM(100, return_sequences=True))\n",
    "model.add(Dropout(0.2))\n",
    "model.add(CuDNNLSTM(100, return_sequences=True))\n",
    "model.add(Dropout(0.2))\n",
    "model.add(CuDNNLSTM(100, stateful=False))\n",
    "model.add(Dropout(0.2))\n",
    "model.add(Dense(1, activation='sigmoid'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer='adam',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 22500 samples, validate on 2500 samples\n",
      "Epoch 1/10\n",
      "22500/22500 [==============================] - 22s 984us/step - loss: 0.5823 - acc: 0.6871 - val_loss: 0.5315 - val_acc: 0.7524\n",
      "Epoch 2/10\n",
      "22500/22500 [==============================] - 21s 928us/step - loss: 0.4323 - acc: 0.8074 - val_loss: 0.4402 - val_acc: 0.8000\n",
      "Epoch 3/10\n",
      "22500/22500 [==============================] - 21s 925us/step - loss: 0.4198 - acc: 0.8123 - val_loss: 0.4431 - val_acc: 0.8132\n",
      "Epoch 4/10\n",
      "22500/22500 [==============================] - 21s 927us/step - loss: 0.4056 - acc: 0.8211 - val_loss: 0.4353 - val_acc: 0.8224\n",
      "Epoch 5/10\n",
      "22500/22500 [==============================] - 21s 923us/step - loss: 0.4073 - acc: 0.8197 - val_loss: 0.4177 - val_acc: 0.8148\n",
      "Epoch 6/10\n",
      "22500/22500 [==============================] - 21s 921us/step - loss: 0.3871 - acc: 0.8284 - val_loss: 0.4371 - val_acc: 0.8264\n",
      "Epoch 7/10\n",
      "22500/22500 [==============================] - 21s 924us/step - loss: 0.3851 - acc: 0.8288 - val_loss: 0.4080 - val_acc: 0.8260\n",
      "Epoch 8/10\n",
      "22500/22500 [==============================] - 21s 928us/step - loss: 0.3863 - acc: 0.8290 - val_loss: 0.4157 - val_acc: 0.8156\n",
      "Epoch 9/10\n",
      "22500/22500 [==============================] - 21s 922us/step - loss: 0.3805 - acc: 0.8311 - val_loss: 0.4010 - val_acc: 0.8284\n",
      "Epoch 10/10\n",
      "22500/22500 [==============================] - 21s 924us/step - loss: 0.3750 - acc: 0.8357 - val_loss: 0.4868 - val_acc: 0.8044\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(x_train, y_train,\n",
    "                    batch_size=batch_size,\n",
    "                    epochs=epochs,\n",
    "                    verbose=1,\n",
    "                    validation_split=0.1,\n",
    "                    # validation_data=(x_test, y_test),\n",
    "                    callbacks=[early_stopping, time_callback])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All epochs took: 3.49 minutes\n"
     ]
    }
   ],
   "source": [
    "times = sum(time_callback.times)\n",
    "print(\"All epochs took:\", round(times/60, 2), \"minutes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x21c1703be48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3Xl8VOX1+PHPyQ5ZWEKAQNhE9pCEGFFEBcQFF7Raq6DWpba0tmp/dvkW+/VbLd1sv61rrXWpS9WvSHEptShVwR2VxQQIO4gmJEBYspNlZs7vjzsJQ8gyhNxMlvN+vfLK3DvPvXMyypx5nufe84iqYowxxjQnLNQBGGOM6fgsWRhjjGmRJQtjjDEtsmRhjDGmRZYsjDHGtMiShTHGmBZZsjDGGNMiSxbGGGNaZMnCGGNMiyJCHUBb6devnw4fPjzUYRhjTKeyZs2a/aqa1FI7V5OFiMwCHgTCgSdV9d4Gzw8FngV6+9vMV9WlDZ7fCNyjqn9s7rWGDx/O6tWr2/gvMMaYrk1EvgymnWvDUCISDjwCXAiMB+aKyPgGze4CFqnqJGAO8JcGz98PvOFWjMYYY4Lj5pzFZGC7qu5U1RpgIXBZgzYKJPgf9wIK6p4Qka8BO4FcF2M0xhgTBDeTxWAgL2A7378v0D3AdSKSDywFbgMQkVjgZ8AvXYzPGGNMkNxMFtLIvob10OcCz6hqCnAR8JyIhOEkiftVtbzZFxCZJyKrRWR1UVFRmwRtjDHmWG5OcOcDQwK2UwgYZvK7GZgFoKorRSQG6AecBlwpIn/Amfz2iUiVqv458GBVfRx4HCArK8sW5jDGGJe4mSxWAaNEZASwG2cC+5oGbb4CZgLPiMg4IAYoUtWz6hqIyD1AecNEYYwxpv24Ngylqh7gVmAZsAnnqqdcEVkgIpf6m/0Y+I6I5AAvAjeqLd1njDEdjnSVz+asrCy1+yyMMd1FcWUNm/eUsbmwlMiIMK49bVirziMia1Q1q6V2XeYObmOM6Yo8Xh9f7K9g054yNhWWsrmwlM17yigsqapvkzm0d6uTRbAsWRhjTAexv7yazYVlbN5Tyib/7237yqnx+ACIDBdGJsVx+kmJjB0Yz9jkBMYNjCcpPtr12CxZGGNMO6v2eNmxr4LNe5xewqZCJznsL6+ub9M/PpqxyQmceXI/xibHM3ZgAiOT4oiKCE39V0sWxhjjElVlX1l1fTLYvKeUzYVl7Cgqx+Nz5oujIsIYPSCO6WOSGOfvKYwZGE9inPu9heNhycIYY9pAVa2XrXvL2FxYxiZ/Uti8p5RDlbX1bQb37sHYgfGcO74/YwcmMC45nuGJsUSEd/zVIixZGGNMEKpqvRyoqOFgeQ0HKqo5WFFDQfFhNvmvSPpifwX+zgI9IsMZMzCeWakD/UkhgTED4unVMzK0f8QJsGRhjOl2VJXKGi8HAj74D1TUcND/c6C8hoMN9lfWeBs917DEnowdGM8laYMY559bGNq3J2FhjVU86rwsWRhjOj1VpbTK4/+wr/Z/2DdIAP7nnJ5BDdX+K4waiooIIzE2ir6xUSTGRXNSUhx967br90fRNzaa/vHRxEZ3j4/R7vFXGtONeX2Kx+fD41U8PnW2vT48PvXva+ax12lf6/X5z6P41P/j48hj5chv35F9qs7xdc8720ce+xS8/nOo/1hv3WP/fq8Pf9sj56/x+jhUWVOfFA5V1lDrbfwG455R4fUf9Elx0YwZkOD/sG+QAGKj6RsXRWxUOCJdq1fQFixZGNOBlVbV8lbuXpbl7uFgRQ21PsXb4IO/7oO81nv0c3Uf/B21SIMIhIkQVv874HHYkcciQnjYkTYiEBkeRp+ekaT06Ul6Sm/6xh350A/84E+MjSImMrztgy8vgo8fhOKvYPaD0KNP279GB2PJwpgOprzawzub9vKvnELe31pEjdfH4N49GN6vJz3DwogME8LDhMjwMMLDhIhwISJMiAgPc36HhRER7m8TJoT7t49q498ODwsj0t82IizwuWOPcdo4H+ThAR/cR7ZB/L/Dw6T+cZiIf/vopNApv71X7IePHoRVT4KnCiQMDuyAb74Kcf1DHZ2rLFkY0wEcrvGyfPM+Xl9XwPLN+6j2+BiYEMM3pwzj4rRkJvX1INWlEBZx5Cc8EsLCj94nYc5XdtO2Kg7Axw/BZ09AbSVMvBKm/czpWSy8Fp6+EL75GvQe0vK5OilLFsaESFWtl3e3FPH6ugLe2bSPw7Ve+sVFM+fUIVySPohThvYhbE8OfPxjyH0NtPGrcY4RmDwaJpMWt1toExEDYy6EUec7+7u6yoPw8cPw2eNQUwGpX4dp/wVJY5zn+41yehX/d5WTMK7/JySODG3MLrGqs8a0o2qPlw+27uff6wt5a+Neyqs99I2NYlbqQC5JS+a0EYmEC7D9beeb7BfvQ1Q8nHIDDJwIPk/Aj/c4t5tp460N7hxVxVBVAr2GODFNuh7iB4T6bW17lQdh5Z/h08ecJDHhcqcn0X9s4+0LsuH5K0DC4frXYMCE9o33BARbddaShTEuq/X6+Gj7fl5fV8iy3D2UVXno1SOSWRMGckl6MlNOSnTu4PXUwIbFzjfZfRshPhlOvwVOuRFieoX6z3B4a2HLG7D6b7DzXae3MfYSOPVmGH5W5x8CO3wIVj4Cn/wVaspg/NecJDFgfMvHFm2Bv18GtYfhulcg5RT3420DliyMCSGP18cnOw/y7/UFvLlhD4cqa4mPjuC8CQOYnTaIqSf3O1IQrqoE1jzjfECVFUD/8XDGbZB6JUREhfTvaNb+7bDmafj8eafHkTgKsr4FGXM739VBh4vhk0fhk79AdSmMuxSmzz/+HsKhXU7CqNgPcxfCiLNaPCTULFkY0868PmXVroO8vs5JEPvLa4iNCufc8QO4eGIyZ49OOvoyzpLdzofTmmedb7EjzoYzfggnz+xc39BrDztzKqv/BvmrIKKHM7Z/6rdgcAf/dl1V4iSJlX+B6hKnlzR9vjPk11qlhfDc15zEcdXfYfQFbRauGzpEshCRWcCDQDjwpKre2+D5ocCzQG9/m/mqulREzgPuBaKAGuCnqrq8udeyZNFFeGthxwpY9xJUFMHJ5zoTqv1GhTqyRvl8ytqvDvH6ukKWri9kX1k1MZFhzBw7gEvSkpkxtv+x1/nv2eAMNW1YDKow4WtOT2LQpND8EW2pcB2sfgrWLYLaCkjOcHobE6+EqNhQR3dEVSl8+ldnXqLKnySm/QyS09rm/BUHnDmMvRvgised5NlBhTxZiEg4sBU4D8gHVgFzVXVjQJvHgc9V9VERGQ8sVdXhIjIJ2KuqBSKSCixT1cHNvZ4li05MFQo+dxLE+sVQuR/t0QeNG0BY0WanTd+RMHoWjJkFQ6c4l42GLFwlJ7+E13MKWLq+kIKSKqIiwpg+OolL0gcxc2z/Y0tAqDpj/B8/DDvegchYyPwmnP596OPuCmchUVXq/Pdc/ZQz/xLdC9LnOImjqUni9lBd5iSJj//sDJ2NucjpSSSnt/1rVZXA/10NX30Clz4Emde3/Wu0gY6QLKYA96jqBf7tOwFU9XcBbR4Ddqrq7/3t/6SqZzQ4jwD7gUGqWk0TLFl0Qoe+hPWLIOclOLANDY+idOhM3oqYwcNfDefLEg9Dw/YzKyqHc8LWkulbTxQeKiSWTbGT2dZrKnn9phIem0hsdARxAT+x0RHExzi/Y6PDiY+OJCYyrNU3gqkquQWlvL6ukH+vLyDv4GEiw4WzRyVxSXoy544bQHxMIwnMW+sM0Xz8EOxZB7H94bTvOh+aPfue4BvYCahC3qew6m+w8TXw1sCwqc7fP+7S9puTqS5zLn/9+GFnEnv0LCdJuN2bq6mEl65zviBc8DuY8n13X68VOkKyuBKYparf9m9/EzhNVW8NaJMM/AfoA8QC56rqmkbO8z1VPbe517Nk0UkcLnY+NHJegq8+dnYln8aHPWfy4J4JbDjg3CV89ugkMof25nCtl4pqL2VVHjyHyxhR+impFZ9wSvWn9NESvAhrfaN525vJ275MduggoPGEEB4mxEaFOwnFn0gCk8tRj2MiiIsOp2dUBOvzS/j3+kK+2F9BeJgw9eR+XJKWzAXjBzZdcrq6DNY+58xJlOQ5k79n3AZpV0NkjEtvbgdXsR+yX3B6G4d2QWwSTLoOTrnJvd5VdTmsegI+eggOH3TuD5k+v33nUjzV8PK3YdMSmP5z5z6NDjQn1RGSxTeACxoki8mqeltAmx/5Y/iTv2fxNyBVVX3+5ycAS4DzVXVHI68xD5gHMHTo0FO+/PJLV/4Wc4I8NbD9LchZCFvfBG8Ntb1Hsqb3BTx6IJP3inoSJjBlZCKz0wYxK3UgvXu28I3T53OGrra+gW59E9mzHoDahGGUDJnJ3uTpFPbKpMwjlFd7qaj2UF7lobza+amobvA44Dlfg38SdbFdkjaICyYMpG9sM7GV7XGGOVY/5QxDDD0Dpt4Ooy6AsI6/wE278Plg53JY9RRsfcPpfYw6D7Judn63xc1+NRVOSY6PHoTKA87c1/Q7IaXFz0R3eD2w5DbI+T+Yciuc/+sOkzA6QrIIZhgqF6f3keff3gmcrqr7RCQFWA7cpKoftfR61rPoYFSdK2NyFkLuK3D4EN4eiWxKPJ+ny0/j5T1JgHDKsD7MTkvmorRk+sefwDfuknzYusxJRjvfA2+1czPbyefA6AudD6HYfkGErVTV+iirrqXCn2QG9oqhX0tLXBZtcYaa1i1yhp7GzYapPwzdh1NnUbIb1j7rXBFWvufEb/arqXSuyvroQecCiZHnOEliyOS2j/14+Xzw5s+c4bDMG+CS+zvEXfAdIVlE4ExwzwR240xwX6OquQFt3gBeUtVnRGQc8A4wGOgFvAcsUNWXg3k9SxYdxIEdzgfmupfg0BdoRAxf9pvOi9Vn8NSe4dRqBKmDE5idNoiL05JJ6dOz7WOoqXASxtY3nARSvhcQ5wNj9AVO8ug/7sS/2anClx854+Bb33RKYWRcC1N+0GVLPrimsZv9xs125jaCudmvptLpzX30gJMkTprhJImhp7VL+EFTheW/hg/+6FwhdfljIb1YAzpAsvAHcRHwAM5lsU+p6m9EZAGwWlWX+K+AegKIAxT4L1X9j4jcBdwJbAs43fmquq+p17JkEUKVB2HDy06CyF+FIhT1m8xrvrN4ZM84Snw9GJkUy6Xpg7kkPZmRSXHtF5vPB4XZ/l7HG1CY4+zvPdSZ5Bw9C4afCREt9ByOOqfXGX/+6CEoWAs9+sLkeTD5O0H1XkwLGt7s12+0kzTS5xx7s1/tYVj9tJMkyvfCiGlOkhg2JTSxB+vDB+Dtu53//77xDET2CFkoHSJZtCdLFu2stsr5Nr3uJdj2H/B5KE0YxVsR03lgbwZ53j4M6duD2WmDmJ0+iLED4ztGSerSAn/iWOZ8g/Uchqg4GDnD+Yc76gKIS2r82JpKZ4J25Z+dCdo+I+CMWyH9GohyoYfU3TV3s1//Cc5d7x/e7wxfDT/LSRLDp4Y66uCtehL+/RPny8rcFyE6PiRhWLIwbc/ng69WwrqFkPtPqC6hOqY/H/aYzp8PnMLnNSn0j4/hkrRBzE5PJmNI746RIJpSUwm7PnCGP7Yuc0ptIM6VMmP8vY4Bqc5VPJ897vzjPnwQBmc5k9ZjL+kQY87dQsOb/SJjnd/DznSubuoEZTUalfMSvHaLcwnvtf8IyeXUlixM2yna6iSIdf+Akq/wRvQkO/YsHis5lberxtKrZzQXTUxmdvogTh3el/DOuFC9qnMfxNZlTvIoWOvsTxjsXE3jqXJu4DrjNuemwI6cBLuyupv98lfDpGudEimd3abXYfFNznBbCBZRsmRhTkx5kVOOImchFGajEsa2uMn8vXwyLx/OICI6jvMnDGR2ejJTT+5HZHgXuyy0bC9sWwbb3oKeic6d1kmjQx2V6ap2LHcWUYpPdtbEaMdFlCxZmOOnCjtXwMq/oDuWI+qlsOdoXqqeygsVp1IW2Zdzxw1gdvogpjUsimeMOTFffQIvXOXMXdywpN2uqLNkYY7PlyupfeuXROavpCwyiX9yNs+Wn8ausCFMG92f2f6SFsfUPDLGtJ3CHHjucmcRpW++CgNTXX/JYJOF/cvvhlSVwpIqcgtKKdr6CRO3PMzEw6so1l487LmBf9TMJGvkQL6TPqj5khbGmLaVnA43vemsifHMxXDdyx3mxk7rWXRxPp/yxYEKcgtKyS0oYWNBKbkFpSRW7uRHEf/gwvBVlBLHu/2uoWj8DYwdOpDUQb0sQRgTSoe+hL9f6swdXrPQ1Yl861l0QzUeH9v2lZG720kMuQWlbCospaLGC0BkuDAtqZwn4/7BJO9b+CJ6UnPaT0k46zYu7SjLdhpjnMKKN73pLKL0/JXOIkpjZoU0JEsWnVRFtYfNe0rZEJAYtu4to9br9BRjo8IZPyiBb2QNYfygBNITKjh5018Iz3nBKaVwxq2ET72D8NjEEP8lxphGJSTDjUudRZReujbkiyhZsugEDlXU1A8jbfD//mJ/BXUjiH1jo5gwKIGbzzyJCYMSmDAogeGJsYSFidON/fA+eONvoD6nHPRZP3b+RzTGdGyxiXDDv+DFObD4Zqfk+ik3hCQUSxYdSODEc25BCRt2l7KxoISCkqr6NoN792D8oAQuTR9E6qBeTBicwMCEmGPvlD58yClw98lfnZIW6dc4dfS74qpsxnRlMQlw7WJY9E341+1QU+4Uq2xnliw6iF37K7jqsZXsK3MWAxSBk/rFkjW8r7+30IsJgxLo09xaCuB88/j0USdRVJXAhCtgxs877BrWxpggRPWEOS/CK9+GZT93Ftea9rN2rSRgyaKDeH9bEfvKqvnvi8aROaw3YwcmHN89DbVVTsG1D+6Dyv1OGe5z/hsGTnQvaGNM+4mIgq8/BVG3w7u/c0qfXPCbdksYliw6iOy8YpLio/n2WSOOr/ietxY+fw7e+1+nEN6IaXDO/8CQU90L1hgTGuERcOmfnbu8P3kEasrgkgfapaClJYsOIievmPSU46jS6vPC+n843zAO7YKUyXDFY12jsJoxpmlhYTDrXidhvP+/ztDz5Y85PQ8XWbLoAEqratlRVMHlkwa33NjncxbeWfFb2L/FGWa6ZpGzEL1VQjWmexCBc+5y1mJ5+25ndci5L7raw7Bk0QGszy8BIH1I76YbqToVUJf/yiml3W+0s8LWuMucbxrGmO7nzP/nXC1VVeL6UJQliw4gO68YgLTBTSSLLz5w1u3N+8RZDvRrj8LEq5zxS2NM95b1rXZ5GVe/korILBHZIiLbRWR+I88PFZEVIvK5iKzzr9ld99yd/uO2iMgFbsYZatl5xZzUL/bYekz5a5yCYs9eAsVfwsV/glvXQMY1liiMMe3KtU8cEQkHHgHOA/KBVSKyRFU3BjS7C1ikqo+KyHhgKTDc/3gOMAEYBLwtIqNV1etWvKGiqmTnFXPmyf2O7NyzAVb8BrYsdRbeOf/XcOq3Q7qouzGme3Pz6+lkYLuq7gQQkYXAZUBgslAgwf+4F1Dgf3wZsFBVq4EvRGS7/3wrXYw3JPaUVlFUVk3GkN6wfzu8+1vY8IpzpcOM/4bTbwnZQu7GGFPHzWQxGMgL2M4HTmvQ5h7gPyJyGxALnBtw7CcNjg3iUqHOJ8c/X3FG5Db4yxwIj4Iz73DWeg7B4u3GGNMYN5NFY9dxNlw8Yy7wjKr+SUSmAM+JSGqQxyIi84B5AEOHDj3BcEMjO6+EyHAYmf07iO0P896F+AGhDssYY47i5gR3PhC46ngKR4aZ6twMLAJQ1ZVADNAvyGNR1cdVNUtVs5KSktow9PaTk1fMt/rmErZ7DUyfb4nCGNMhuZksVgGjRGSEiEThTFgvadDmK2AmgIiMw0kWRf52c0QkWkRGAKOAz1yMNSS8PmXj7oN8u+Z5576JjGtDHZIxxjTKtWEoVfWIyK3AMiAceEpVc0VkAbBaVZcAPwaeEJE7cIaZblRnnddcEVmEMxnuAX7QFa+E2llUzvmeFSRVfwmXPWeXwxpjOixbgzuEXv50G1OWnk/fAcOIuWWFleswxrQ7W4O7E+iZ8xSD5CC+C56xRGGM6dCsqFCoHC7mzMK/kxN9CmEjp4U6GmOMaZYlixDxfPAg8VrO56N/GOpQjDGmRZYsQqFsD2Gf/oUl3ikkj214n6IxxnQ8lixC4b3fg8/DnzzfYFJzZcmNMaaDsAnu9nZgB6x5lo96zaYmajj9E2JCHZExxrTIehbtbfmvISKa+6svIz3FehXGmM7BkkV7Kvgccl+hKuu7rD0U3fzKeMYY04FYsmhP7yyAHn1YPfh6ANKH9ApxQMYYExxLFu1l53uwYzmc9WPW7vUiAhMHW7IwxnQOlizagyq8fQ8kpMCp3yEnr5iTk+KIj4ls8VBjjOkILFm0h01LoGAtzLgTjYgmJ7/Y5iuMMZ2KJQu3eT3wzq8gaSykz2V38WH2l9dYsjDGdCp2n4Xbsp+HA9vg6hcgLJycvBIAMuyyWWNMJ2I9CzfVVMK790LKZBh7MQDZeYeIighjzMD4EAdnjDHBs56Fmz57HMoK4et/qy9BnpNXQuqgBKIiLE8bYzoP+8Ryy+FD8OF9cPJ5MHwqAB6vj/W7S2y+whjT6ViycMuHD0BVKZx7d/2ubfvKOVzrJcOShTGmk3E1WYjILBHZIiLbRWR+I8/fLyLZ/p+tIlIc8NwfRCRXRDaJyEMinWgpudIC+PSvMPEbMHBi/e6cPOfPs5pQxpjOxrU5CxEJBx4BzgPygVUiskRVN9a1UdU7AtrfBkzyPz4DmAqk+Z/+EJgGvOtWvG3qvd+Dzwszfn7U7pz8Ynr1iGRYYs8QBWaMMa3jZs9iMrBdVXeqag2wELismfZzgRf9jxWIAaKAaCAS2OtirG1n/zZY+xxk3QR9Rxz1VHaeM1/RmTpJxhgD7iaLwUBewHa+f98xRGQYMAJYDqCqK4EVQKH/Z5mqbmrkuHkislpEVhcVFbVx+K20/NcQEQNn//So3ZU1HrbuLSMjxepBGWM6HzeTRWNfn7WJtnOAxarqBRCRk4FxQApOgjlHRM4+5mSqj6tqlqpmJSUltVHYJ2D3Wtj4GpxxK8T1P+qp3IJSvD61K6GMMZ2Sm8kiHxgSsJ0CFDTRdg5HhqAALgc+UdVyVS0H3gBOdyXKtvT2PdAzEabcesxTdZPbaTa5bYzphNxMFquAUSIyQkSicBLCkoaNRGQM0AdYGbD7K2CaiESISCTO5PYxw1Adyo7l8MV7cNZPICbhmKez84oZ3LsHSfHRIQjOGGNOTIvJQkRuFZE+x3tiVfUAtwLLcD7oF6lqrogsEJFLA5rOBRaqauAQ1WJgB7AeyAFyVPVfxxtDu/H54O1fQq8hcOrNjTbJyS+2+yuMMZ1WMJfODsS57HUt8BTOZHNTcw9HUdWlwNIG+37RYPueRo7zAt8N5jU6hI2vQWE2fO1RiDi253CgvJq8g4f55unDQhCcMcacuBZ7Fqp6FzAK+BtwI7BNRH4rIiNdjq1z8NbC8l9B//GQdnWjTXLynfmKjCHH3UEzxpgOIag5C39PYo//x4Mzx7BYRP7gYmydw+fPwcGdMPMXEBbeaJPsvBLCBFIHHzuXYYwxnUGLw1AicjtwA7AfeBL4qarWikgYsA34L3dD7MBqKuHd38OQ02H0rCab5eQVM3pAPD2jrMivMaZzCubTqx9whap+GbhTVX0icok7YXUSnz4K5XvgG8/UlyBvSFXJyS9m1oSB7RubMca0oWCGoZYCB+s2RCReRE4DaOyu6m6j8iB8+KDToxg2pclmXx2spLiy1m7GM8Z0asEki0eB8oDtCv++7u3D+6G61JmraEa2VZo1xnQBwSQLCbxUVlV9dPcV9kp2O6vgpV0NAyY02zQnr4SYyDBGD4hrp+CMMabtBZMsdorI7SIS6f/5IbDT7cA6tHd/B+o7pgR5Y3Lyi5k4uBcR4bbOlDGm8wrmE+x7wBnAbpx6T6cB89wMqkMr2grZL0DWzdCn+Zvsar0+NuwusSEoY0yn1+Jwkqruw6nrZACWL4DInnD2T1psumVPGdUen01uG2M6vWDus4gBbgYm4CxIBICqfsvFuDqm/NWw6V8w/U6I7ddi87rJbasJZYzp7IIZhnoOpz7UBcB7OKXGy9wMqkNS9Zcg7wdTfhDUITl5xSTGRpHSp4e7sRljjMuCSRYnq+r/ABWq+ixwMTDR3bA6oB3vwK4PYNp/QXR8UIfk5BfbMqrGmC4hmGRR6/9dLCKpQC9guGsRdUQ+n9Or6D0UTrkxqEPKqz1s21duk9vGmC4hmPslHvevZ3EXzuJFccD/uBpVR5P7CuxZD5c/3mgJ8saszy9BFdKH2JrbxpjOr9lk4S8WWKqqh4D3gZPaJaqOxFPjlCAfkAoTvxH0YXVlya1nYYzpCpodhvLfrX3sgtLdydpn4dAumHk3hAV/Y11OXjHDEnvSJzbKvdiMMaadBPPp95aI/EREhohI37qfYE4uIrNEZIuIbBeR+Y08f7+IZPt/topIccBzQ0XkPyKySUQ2isjwoP+qtlJdDu/9AYaeAaPOO65Dc/KKrVdhjOkygpmzqLufIvB6UaWFISkRCQceAc7DufN7lYgsUdWN9SdRvSOg/W3ApIBT/B34jaq+JSJxgC+IWNvWp49CxT6Y80KTJcgbs6+0ioKSKrsZzxjTZQRzB/eIVp57MrBdVXcCiMhC4DJgYxPt5wJ3+9uOByJU9S1/DOVNHOOeyoPw0UMw5mIYMvm4Ds3JLwEgwya3jTFdRDB3cF/f2H5V/XsLhw4G8gK26+pKNfYaw4ARwHL/rtE4l+q+4t//NjBfVb0txdtmPvgT1JTDzOO/8Csnr5jwMGHCIEsWxpiuIZhhqFMDHscAM4G1OMNEzWls3EYb2QdO7anFAckgAjgLZ1jqK+Al4Ebgb0e9gMg8/EUNhw4d2kI4x6E4zylBnj4X+o877sNz8osZOzCemMjG1+Q2xpjOJphhqNsCt0WkF04JkJbkA0MCtlOAgibazuHoOZF84POAIazXgNNpkCxU9XHgcYCsrKymEtHxe/deQJwaUMfJ51Oy84o4wp4NAAAYH0lEQVS5NH1Qm4VjjDGh1ppFFiqBUUG0WwWMEpERIhKFkxCWNGwkImOAPsDKBsf2EZEk//Y5ND3X0bb2bYac/4PJ34HeQ1pu38AXByooq/LY5LYxpksJZs7iXxwZPgoDxgOLWjpOVT0iciuwDAgHnlLVXBFZAKxW1brEMRdY2GA1Pq+I/AR4R5zCSmuAJ47j72q9dxZAVByc+aNWHZ5jlWaNMV1QMHMWfwx47AG+VNX8YE6uqkuBpQ32/aLB9j1NHPsWkBbM67SZvM9gy79hxl0Qm9iqU+TkFRMbFc7IJFtG1RjTdQSTLL4CClW1CkBEeojIcFXd5Wpk7a2uBHlsfzj9llafJju/hIkpvQgPs0qzxpiuI5g5i39w9A1xXv++rmXbW/DlR/4S5K3rFVR7vGwqKLX5CmNMlxNMsohQ1Zq6Df/jrlXwyOeDd34JfYZD5g2tPs3mwjJqvD4yrMyHMaaLCSZZFInIpXUbInIZsN+9kEJgw2LYuwHO+R+IaH0erK80az0LY0wXE8ycxfeAF0Tkz/7tfKDRu7o7JU8NLP81DJwIE644oVNl5xWTFB9Ncq+YlhsbY0wnEsxNeTuA0/3F/ERVu9b622WFEJ0AM+85rhLkjamrNGvLqBpjupoWPx1F5Lci0ltVy1W1TET6iMiv2yO4dtFnGHz3fTh55gmdprSqlh1FFVY80BjTJQXzVfpCVa1fZ8K/at5F7oUUAmFhx1WCvDHr/ZVmbb7CGNMVBZMswkWkfuFpEekBBLcQdTeS7b9zO82uhDLGdEHBTHA/j1N242n/9k3As+6F1Dll5xVzUlIsvXpEhjoUY4xpc8FMcP9BRNYB5+KUHX8TGOZ2YJ2JqlNp9qyT+4U6FGOMcUWwl//swbmL++s461lsci2iTmhPaRVFZdU2X2GM6bKa7FmIyGicsuJzgQM4CxCJqs5op9g6jbpKs5YsjDFdVXPDUJuBD4DZqrodQETuaJeoOpnsvBIiw4VxyfGhDsUYY1zR3DDU13GGn1aIyBMiMpPGl0rt9nLyihmfnEB0hC2jaozpmppMFqr6qqpeDYwF3gXuAAaIyKMicn47xdfheX3K+t0lNgRljOnSWpzgVtUKVX1BVS/BWUc7G5jvemSdxM6icsqrPaTb/RXGmC7suIohqepBVX1MVc9xK6DOJtsmt40x3cCJVc5rgYjMEpEtIrJdRI7pjYjI/SKS7f/ZKiLFDZ5PEJHdARVvO5yc/GLiYyI4qV9sqEMxxhjXBHMHd6uISDjwCHAeTlnzVSKyRFU31rVR1TsC2t8GTGpwml8B77kVY1vI9leaDbNlVI0xXZibPYvJwHZV3elfXW8hcFkz7ecCL9ZtiMgpwADgPy7GeEKqar1sLiwj3SrNGmO6ODeTxWAgL2A737/vGCIyDBgBLPdvhwF/An7qYnwnLLegFI9PbXLbGNPluZksGhuX0SbazgEWq6rXv/19YKmq5jXR3nkBkXkislpEVhcVFZ1AqK1Td+d2hk1uG2O6ONfmLHB6EkMCtlOAgibazgF+ELA9BThLRL4PxAFRIlKuqkdNkqvq48DjAFlZWU0lItfk5BeT3CuG/gm2jKoxpmtzM1msAkaJyAhgN05CuKZhIxEZA/QBVtbtU9VrA56/EchqmCg6grplVI0xpqtzbRhKVT3ArcAynCq1i1Q1V0QWiMilAU3nAgtVtd17BieiuLKGXQcq7f4KY0y34GbPAlVdCixtsO8XDbbvaeEczwDPtHFoJyynfhlVuxLKGNP1uXpTXleWk1eMCEwcbMnCGNP1WbJopZy8Yk5OiiM+xpZRNcZ0fZYsWkFVyckvtvkKY0y3YcmiFXYXH2Z/eY3dX2GM6TYsWbRCtt2MZ4zpZixZtEJOXjFREWGMGWjLqBpjugdLFq2Qk1dC6qAEIsPt7TPGdA/2aXecPF6fLaNqjOl2LFkcp237yjlc67X5CmNMt2LJ4jjVVZq1mlDGmO7EksVxyskvplePSIYl9gx1KMYY024sWRyn7DxnvkLEllE1xnQfliyOQ2WNh617y8hIsXpQxpjuxZLFccgtKMXrU7sSyhjT7ViyOA71k9uWLIwx3Ywli+OQnVdMSp8e9IuLDnUoxhjTrixZHIfsPKs0a4zpnlxNFiIyS0S2iMh2ETlmDW0RuV9Esv0/W0Wk2L8/Q0RWikiuiKwTkavdjDMY+8uryT90mAy7v8IY0w25tqyqiIQDjwDnAfnAKhFZoqob69qo6h0B7W8DJvk3K4HrVXWbiAwC1ojIMlUtdivelqzLt/kKY0z35WbPYjKwXVV3qmoNsBC4rJn2c4EXAVR1q6pu8z8uAPYBSS7G2qLsvBLCBFIHJ4QyDGOMCQk3k8VgIC9gO9+/7xgiMgwYASxv5LnJQBSww4UYg5aTV8zoAfH0jHKtM2aMMR2Wm8misVuctYm2c4DFquo96gQiycBzwE2q6jvmBUTmichqEVldVFR0wgE3pW4ZVSseaIzprtxMFvnAkIDtFKCgibZz8A9B1RGRBODfwF2q+kljB6nq46qapapZSUnujVJ9dbCS4spam68wxnRbbiaLVcAoERkhIlE4CWFJw0YiMgboA6wM2BcFvAr8XVX/4WKMQcm2SrPGmG7OtWShqh7gVmAZsAlYpKq5IrJARC4NaDoXWKiqgUNUVwFnAzcGXFqb4VasLcnJKyEmMozRA+JCFYIxxoSUq7O1qroUWNpg3y8abN/TyHHPA8+7GdvxyMkvZuLgXkTYMqrGmG7KPv1aUOv1sWF3iU1uG2O6NUsWLdiyp4xqj88mt40x3ZolixbY5LYxxliyaFFOXjGJsVGk9OkR6lCMMSZkLFm0ICe/2JZRNcZ0e5YsmlFe7WHbvnIbgjLGdHuWLJqxPr8EVUgfYmtuG2O6N0sWzcjJt8ltY4wBSxbNyskrZlhiT/rERoU6FGOMCSlLFs3IySu2XoUxxmDJokn7SqsoKKmym/GMMQaXa0N1Zjn5JQBW5sOYEKitrSU/P5+qqqpQh9JlxMTEkJKSQmRkZKuOt2TRhJy8YiLChAmDbBlVY9pbfn4+8fHxDB8+3O5xagOqyoEDB8jPz2fEiBGtOocNQzUhO6+YscnxxESGhzoUY7qdqqoqEhMTLVG0EREhMTHxhHpqliwa4fM5y6ja5LYxoWOJom2d6PtpyaIRXxyooKzKY5PbxnRTBw4cICMjg4yMDAYOHMjgwYPrt2tqaoI6x0033cSWLVuabfPII4/wwgsvtEXIrrM5i0bk+CvN2uS2Md1TYmIi2dnZANxzzz3ExcXxk5/85Kg2qoqqEhbW+Hfup59+usXX+cEPfnDiwbYT61k0IievmNiocEYm2TKqxpgjtm/fTmpqKt/73vfIzMyksLCQefPmkZWVxYQJE1iwYEF92zPPPJPs7Gw8Hg+9e/dm/vz5pKenM2XKFPbt2wfAXXfdxQMPPFDffv78+UyePJkxY8bw8ccfA1BRUcHXv/510tPTmTt3LllZWfWJrD252rMQkVnAg0A48KSq3tvg+fuBGf7NnkB/Ve3tf+4G4C7/c79W1WfdjDVQdn4JE1N6ER5mY6bGhNov/5XLxoLSNj3n+EEJ3D17QquO3bhxI08//TR//etfAbj33nvp27cvHo+HGTNmcOWVVzJ+/PijjikpKWHatGnce++9/OhHP+Kpp55i/vz5x5xbVfnss89YsmQJCxYs4M033+Thhx9m4MCBvPzyy+Tk5JCZmdmquE+Uaz0LEQkHHgEuBMYDc0XkqHdQVe9Q1QxVzQAeBl7xH9sXuBs4DZgM3C0ifdyKNVC1x8umglKbrzDGNGrkyJGceuqp9dsvvvgimZmZZGZmsmnTJjZu3HjMMT169ODCCy8E4JRTTmHXrl2NnvuKK644ps2HH37InDlzAEhPT2fChNYluRPlZs9iMrBdVXcCiMhC4DLg2HfSMRcnQQBcALylqgf9x74FzAJedDFeADYXllHj9ZFhV0IZ0yG0tgfgltjY2PrH27Zt48EHH+Szzz6jd+/eXHfddY1enhoVdaS+XHh4OB6Pp9FzR0dHH9NGVdsy/FZzc85iMJAXsJ3v33cMERkGjACWH++xba2+0qz1LIwxLSgtLSU+Pp6EhAQKCwtZtmxZm7/GmWeeyaJFiwBYv359oz2X9uBmz6KxAf+mUuQcYLGqeo/nWBGZB8wDGDp0aGtiPEZ2XjFJ8dEk94ppk/MZY7quzMxMxo8fT2pqKieddBJTp05t89e47bbbuP7660lLSyMzM5PU1FR69Wr/NXbErS6OiEwB7lHVC/zbdwKo6u8aafs58ANV/di/PReYrqrf9W8/Bryrqk0OQ2VlZenq1atPOO6Zf3qXk5LieOL6rBM+lzGmdTZt2sS4ceNCHUaH4PF48Hg8xMTEsG3bNs4//3y2bdtGRMTxf9dv7H0VkTWq2uIHnps9i1XAKBEZAezG6T1c07CRiIwB+gArA3YvA34bMKl9PnCni7ECUFpVy46iCq7ITHH7pYwxJijl5eXMnDkTj8eDqvLYY4+1KlGcKNdeUVU9InIrzgd/OPCUquaKyAJgtaou8TedCyzUgC6Oqh4UkV/hJByABXWT3W5al+dUmrUyH8aYjqJ3796sWbMm1GG4e5+Fqi4FljbY94sG2/c0cexTwFOuBdeIusntiSm25rYxxgSyO7gDZOcVc1JSLL16tK7euzHGdFWWLPxUley8Yru/whhjGmHJwm9PaRVFZdV2f4UxxjTCkoVfXaVZSxbGmOnTpx9zg90DDzzA97///SaPiYtzCo8WFBRw5ZVXNnneli7xf+CBB6isrKzfvuiiiyguLg42dNdYsvDLzishMlwYlxwf6lCMMSE2d+5cFi5ceNS+hQsXMnfu3BaPHTRoEIsXL271azdMFkuXLqV379B/ibVk4ZeTV8z45ASiI2wZVWO6uyuvvJLXX3+d6upqAHbt2kVBQQEZGRnMnDmTzMxMJk6cyD//+c9jjt21axepqakAHD58mDlz5pCWlsbVV1/N4cOH69vdcsst9aXN777bKYv30EMPUVBQwIwZM5gxwynIPXz4cPbv3w/AfffdR2pqKqmpqfWlzXft2sW4ceP4zne+w4QJEzj//POPep22YosfAV6fsn53CVdktkv5KWPM8XhjPuxZ37bnHDgRLry3yacTExOZPHkyb775JpdddhkLFy7k6quvpkePHrz66qskJCSwf/9+Tj/9dC699NImlyx99NFH6dmzJ+vWrWPdunVHlRf/zW9+Q9++ffF6vcycOZN169Zx++23c99997FixQr69et31LnWrFnD008/zaeffoqqctpppzFt2jT69OnDtm3bePHFF3niiSe46qqrePnll7nuuuva5r3ys54FsLOonPJqj62MZ4ypFzgUVTcEpar8/Oc/Jy0tjXPPPZfdu3ezd+/eJs/x/vvv139op6WlkZaWVv/cokWLyMzMZNKkSeTm5rZYIPDDDz/k8ssvJzY2lri4OK644go++OADAEaMGEFGRgbQfAn0E2E9C5z7K8Amt43pkJrpAbjpa1/7Gj/60Y9Yu3Ythw8fJjMzk2eeeYaioiLWrFlDZGQkw4cPb7QkeaDGeh1ffPEFf/zjH1m1ahV9+vThxhtvbPE8zdXxqyttDk55czeGoaxngXPndnxMBCMSY1tubIzpFuLi4pg+fTrf+ta36ie2S0pK6N+/P5GRkaxYsYIvv/yy2XOcffbZvPDCCwBs2LCBdevWAU5p89jYWHr16sXevXt544036o+Jj4+nrKys0XO99tprVFZWUlFRwauvvspZZ53VVn9ui6xngdOzSE/pTZgto2qMCTB37lyuuOKK+uGoa6+9ltmzZ5OVlUVGRgZjx45t9vhbbrmFm266ibS0NDIyMpg8eTLgrHg3adIkJkyYcExp83nz5nHhhReSnJzMihUr6vdnZmZy44031p/j29/+NpMmTXJlyKkxrpUob2+tLVFeVesl9e5lfHfaSfz0gub/wxtj2oeVKHfHiZQo7/bDUGVVHi5OS+aMkf1abmyMMd1Utx+GSoqP5sE5k0IdhjHGdGjdvmdhjDGmZZYsjDEdUleZT+0oTvT9tGRhjOlwYmJiOHDggCWMNqKqHDhwgJiYmFafo9vPWRhjOp6UlBTy8/MpKioKdShdRkxMDCkpKa0+3tVkISKzgAdx1uB+UlWPuRVTRK4C7gEUyFHVa/z7/wBcjNP7eQv4odrXDGO6hcjISEaMGBHqMEwA15KFiIQDjwDnAfnAKhFZoqobA9qMAu4EpqrqIRHp799/BjAVqCuk8iEwDXjXrXiNMcY0zc05i8nAdlXdqao1wELgsgZtvgM8oqqHAFR1n3+/AjFAFBANRAJNV+syxhjjKjeTxWAgL2A7378v0GhgtIh8JCKf+IetUNWVwAqg0P+zTFU3NXwBEZknIqtFZLWNbRpjjHvcnLNorNBSwzmHCGAUMB1IAT4QkVSgHzDOvw/gLRE5W1XfP+pkqo8DjwOISJGINF/Vq3n9gP0ncHxXYu/F0ez9OJq9H0d0hfdiWDCN3EwW+cCQgO0UoKCRNp+oai3whYhs4Ujy+ERVywFE5A3gdOB9mqCqSScSrIisDqY+Sndg78XR7P04mr0fR3Sn98LNYahVwCgRGSEiUcAcYEmDNq8BMwBEpB/OsNRO4CtgmohEiEgkzuT2McNQxhhj2odryUJVPcCtwDKcD/pFqporIgtE5FJ/s2XAARHZiDNH8VNVPQAsBnYA64EcnEtq/+VWrMYYY5rXZUqUnygRmeefA+n27L04mr0fR7P344ju9F5YsjDGGNMiqw1ljDGmRd0+WYjILBHZIiLbRWR+qOMJJREZIiIrRGSTiOSKyA9DHVOoiUi4iHwuIq+HOpZQE5HeIrJYRDb7/x+ZEuqYQklE7vD/O9kgIi+KSOur9HUC3TpZBJQkuRAYD8wVkfGhjSqkPMCPVXUczqXKP+jm7wfAD7Er8eo8CLypqmOBdLrx+yIig4HbgSxVTcWpfzcntFG5q1snC4IrSdJtqGqhqq71Py7D+TBoeNd9tyEiKTjFLJ8MdSyhJiIJwNnA3wBUtUZVi0MbVchFAD1EJALoybH3kXUp3T1ZBFOSpFsSkeHAJODT0EYSUg8A/wX4Qh1IB3ASUAQ87R+We1JEYkMdVKio6m7gjzj3hBUCJar6n9BG5a7uniyCKUnS7YhIHPAy8P9UtTTU8YSCiFwC7FPVNaGOpYOIADKBR1V1ElABdNs5PhHpgzMKMQIYBMSKyHWhjcpd3T1ZBFOSpFvx3zH/MvCCqr4S6nhCaCpwqYjswhmePEdEng9tSCGVD+Sral1PczFO8uiuzgW+UNUif7miV4AzQhyTq7p7sgimJEm3ISKCMya9SVXvC3U8oaSqd6pqiqoOx/n/Yrmqdulvjs1R1T1AnoiM8e+aCWxs5pCu7ivgdBHp6f93M5MuPuHfrZdVVVWPiNSVJAkHnlLV3BCHFUpTgW8C60Uk27/v56q6NIQxmY7jNuAF/xerncBNIY4nZFT1UxFZDKzFuYrwc/wVsLsqu4PbGGNMi7r7MJQxxpggWLIwxhjTIksWxhhjWmTJwhhjTIssWRhjjGmRJQtjWiAiXhHJDvhpszuXRWS4iGxoq/MZ45ZufZ+FMUE6rKoZoQ7CmFCynoUxrSQiu0Tk9yLymf/nZP/+YSLyjois8/8e6t8/QEReFZEc/09deYhwEXnCvzbCf0Skh7/97SKy0X+ehSH6M40BLFkYE4weDYahrg54rlRVJwN/xqlSi//x31U1DXgBeMi//yHgPVVNx6mrVFctYBTwiKpOAIqBr/v3zwcm+c/zPbf+OGOCYXdwG9MCESlX1bhG9u8CzlHVnf4CjHtUNVFE9gPJqlrr31+oqv1EpAhIUdXqgHMMB95S1VH+7Z8Bkar6axF5EygHXgNeU9Vyl/9UY5pkPQtjTow28bipNo2pDnjs5chc4sU4KzmeAqzxL7JjTEhYsjDmxFwd8Hul//HHHFli81rgQ//jd4BboH5t74SmTioiYcAQVV2BswBTb+CY3o0x7cW+qRjTsh4BVXjBWYe67vLZaBH5FOeL11z/vtuBp0Tkpziry9VVZ/0h8LiI3IzTg7gFZ5W1xoQDz4tIL5xFuu63ZUxNKNmchTGt5J+zyFLV/aGOxRi32TCUMcaYFlnPwhhjTIusZ2GMMaZFliyMMca0yJKFMcaYFlmyMMYY0yJLFsYYY1pkycIYY0yL/j+PF8PSl9VFygAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x21d97ed3ac8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# inspect the model        \n",
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25000/25000 [==============================] - 9s 379us/step\n",
      "Test score: 0.4553125735807419\n",
      "Test accuracy: 0.8136800014781952\n"
     ]
    }
   ],
   "source": [
    "score, acc = model.evaluate(x_test, y_test,\n",
    "                            batch_size=batch_size)\n",
    "print('Test score:', score)\n",
    "print('Test accuracy:', acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# CuDNNLSTM took 21s per epoch, while normal LSTM took around 5 minutes per epoch. Quite a speed up don't you think?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Resources and References:\n",
    "# http://www.samyzaf.com/ML/imdb/imdb.html\n",
    "# https://medium.com/@thoszymkowiak/how-to-implement-sentiment-analysis-using-word-embedding-and-convolutional-neural-networks-on-keras-163197aef623"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}