bAbI_story_que_ans.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function, division\n",
    "from builtins import range, input\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import keras.backend as K\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "import tarfile\n",
    "\n",
    "from keras.models import Model\n",
    "from keras.layers import Dense, Embedding, Input, Lambda, Reshape, add, dot, Activation\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from keras.optimizers import Adam, RMSprop\n",
    "from keras.utils.data_utils import get_file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = get_file(\n",
    "  'babi-tasks-v1-2.tar.gz', \n",
    "  origin='https://s3.amazonaws.com/text-datasets/babi_tasks_1-20_v1-2.tar.gz')\n",
    "tar = tarfile.open(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "challenges = {\n",
    "  # QA1 with 10,000 samples\n",
    "  'single_supporting_fact_10k': 'tasks_1-20_v1-2/en-10k/qa1_single-supporting-fact_{}.txt',\n",
    "  # QA2 with 10,000 samples\n",
    "  'two_supporting_facts_10k': 'tasks_1-20_v1-2/en-10k/qa2_two-supporting-facts_{}.txt',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize(sent):\n",
    "    return [x.strip() for x in re.split('(\\W+?)', sent) if x.strip()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_stories(f):\n",
    "  \n",
    "  data = []\n",
    "\n",
    "  # use this list to keep track of the story so far\n",
    "  story = []\n",
    "\n",
    "  # print a random story, helpful to see the data\n",
    "  printed = False\n",
    "  for line in f:\n",
    "    line = line.decode('utf-8').strip()\n",
    "\n",
    "    # split the line number from the rest of the line\n",
    "    nid, line = line.split(' ', 1)\n",
    "\n",
    "    # see if we should begin a new story\n",
    "    if int(nid) == 1:\n",
    "      story = []\n",
    "\n",
    "    \n",
    "    if '\\t' in line:\n",
    "      q, a, supporting = line.split('\\t')\n",
    "      q = tokenize(q)\n",
    "\n",
    "      \n",
    "      story_so_far = [[str(i)] + s for i, s in enumerate(story) if s]\n",
    "\n",
    "      \n",
    "      data.append((story_so_far, q, a))\n",
    "      story.append('')\n",
    "    else:\n",
    "      # just add the line to the current story\n",
    "      story.append(tokenize(line))\n",
    "  return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# recursively flatten a list\n",
    "def should_flatten(el): \n",
    "  return not isinstance(el, (str, bytes))\n",
    "\n",
    "def flatten(l):\n",
    "  for el in l:\n",
    "    if should_flatten(el):\n",
    "      yield from flatten(el)\n",
    "    else:\n",
    "      yield el"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert stories from words into lists of word indexes (integers)\n",
    "def vectorize_stories(data, word2idx, story_maxlen, query_maxlen):\n",
    "  inputs, queries, answers = [], [], []\n",
    "  for story, query, answer in data:\n",
    "    inputs.append([[word2idx[w] for w in s] for s in story])\n",
    "    queries.append([word2idx[w] for w in query])\n",
    "    answers.append([word2idx[answer]])\n",
    "  return (\n",
    "    [pad_sequences(x, maxlen=story_maxlen) for x in inputs],\n",
    "    pad_sequences(queries, maxlen=query_maxlen),\n",
    "    np.array(answers)\n",
    "  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is like 'pad_sequences' but for entire stories\n",
    "\n",
    "def stack_inputs(inputs, story_maxsents, story_maxlen):\n",
    "  for i, story in enumerate(inputs):\n",
    "    inputs[i] = np.concatenate(\n",
    "      [\n",
    "        story, \n",
    "        np.zeros((story_maxsents - story.shape[0], story_maxlen), 'int')\n",
    "      ]\n",
    "    )\n",
    "  return np.stack(inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def get_data(challenge_type):\n",
    "  # input should either be 'single_supporting_fact_10k' or 'two_supporting_facts_10k'\n",
    "  challenge = challenges[challenge_type]\n",
    "\n",
    "\n",
    "\n",
    "  train_stories = get_stories(tar.extractfile(challenge.format('train')))\n",
    "  test_stories = get_stories(tar.extractfile(challenge.format('test')))\n",
    "\n",
    "\n",
    "  # group all the stories together\n",
    "  stories = train_stories + test_stories\n",
    "\n",
    "  # so we can get the max length of each story, of each sentence, and of each question\n",
    "  story_maxlen = max((len(s) for x, _, _ in stories for s in x))\n",
    "  story_maxsents = max((len(x) for x, _, _ in stories))\n",
    "  query_maxlen = max(len(x) for _, x, _ in stories)\n",
    "\n",
    "  # Create vocabulary of corpus and find size, including a padding element.\n",
    "  vocab = sorted(set(flatten(stories)))\n",
    "  vocab.insert(0, '<PAD>')\n",
    "  vocab_size = len(vocab)\n",
    "\n",
    "  # Create an index mapping for the vocabulary.\n",
    "  word2idx = {c:i for i, c in enumerate(vocab)}\n",
    "\n",
    "  # convert stories from strings to lists of integers\n",
    "  inputs_train, queries_train, answers_train = vectorize_stories(\n",
    "    train_stories, \n",
    "    word2idx,\n",
    "    story_maxlen,\n",
    "    query_maxlen\n",
    "  )\n",
    "  inputs_test, queries_test, answers_test = vectorize_stories(\n",
    "    test_stories, \n",
    "    word2idx,\n",
    "    story_maxlen,\n",
    "    query_maxlen\n",
    "  )\n",
    "\n",
    "  # convert inputs into 3-D numpy arrays\n",
    "  inputs_train = stack_inputs(inputs_train, story_maxsents, story_maxlen)\n",
    "  inputs_test = stack_inputs(inputs_test, story_maxsents, story_maxlen)\n",
    "  print(\"inputs_train.shape, inputs_test.shape\", inputs_train.shape, inputs_test.shape)\n",
    "\n",
    "\n",
    "  # return model inputs for keras\n",
    "  return train_stories, test_stories, \\\n",
    "    inputs_train, queries_train, answers_train, \\\n",
    "    inputs_test, queries_test, answers_test, \\\n",
    "    story_maxsents, story_maxlen, query_maxlen, \\\n",
    "    vocab, vocab_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inputs_train.shape, inputs_test.shape (10000, 10, 8) (1000, 10, 8)\n"
     ]
    }
   ],
   "source": [
    "# get the single supporting fact data\n",
    "train_stories, test_stories, \\\n",
    "  inputs_train, queries_train, answers_train, \\\n",
    "  inputs_test, queries_test, answers_test, \\\n",
    "  story_maxsents, story_maxlen, query_maxlen, \\\n",
    "  vocab, vocab_size = get_data('single_supporting_fact_10k')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input_story_.shape, embedded_story.shape: (None, 10, 8) (None, 10, 15)\n",
      "inp_q.shape, emb_q.shape: (None, 4) (None, 1, 15)\n",
      "story_weights.shape: (None, 10, 1)\n"
     ]
    }
   ],
   "source": [
    "##### create the model #####\n",
    "embedding_dim = 15\n",
    "\n",
    "input_story_ = Input((story_maxsents, story_maxlen))\n",
    "embedded_story = Embedding(vocab_size, embedding_dim)(input_story_)\n",
    "embedded_story = Lambda(lambda x: K.sum(x, axis=2))(embedded_story)\n",
    "print(\"input_story_.shape, embedded_story.shape:\", input_story_.shape, embedded_story.shape)\n",
    "\n",
    "\n",
    "input_question_ = Input((query_maxlen,))\n",
    "embedded_question = Embedding(vocab_size, embedding_dim)(input_question_)\n",
    "embedded_question = Lambda(lambda x: K.sum(x, axis=1))(embedded_question)\n",
    "\n",
    "embedded_question = Reshape((1, embedding_dim))(embedded_question)\n",
    "print(\"inp_q.shape, emb_q.shape:\", input_question_.shape, embedded_question.shape)\n",
    "\n",
    "\n",
    "x = dot([embedded_story, embedded_question], 2)\n",
    "x = Reshape((story_maxsents,))(x) # flatten the vector\n",
    "x = Activation('softmax')(x)\n",
    "story_weights = Reshape((story_maxsents, 1))(x) # unflatten it again to be dotted later\n",
    "print(\"story_weights.shape:\", story_weights.shape)\n",
    "\n",
    "\n",
    "\n",
    "x = dot([story_weights, embedded_story], 1)\n",
    "x = Reshape((embedding_dim,))(x) # flatten it again\n",
    "ans = Dense(vocab_size, activation='softmax')(x)\n",
    "\n",
    "# make the model\n",
    "model = Model([input_story_, input_question_], ans)\n",
    "\n",
    "# compile the model\n",
    "model.compile(\n",
    "  optimizer=RMSprop(lr=1e-2),\n",
    "  loss='sparse_categorical_crossentropy',\n",
    "  metrics=['accuracy']\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/4\n",
      "313/313 [==============================] - 1s 3ms/step - loss: 0.7465 - accuracy: 0.7360 - val_loss: 0.0461 - val_accuracy: 0.9860\n",
      "Epoch 2/4\n",
      "313/313 [==============================] - 1s 2ms/step - loss: 0.0091 - accuracy: 0.9975 - val_loss: 1.0588e-04 - val_accuracy: 1.0000\n",
      "Epoch 3/4\n",
      "313/313 [==============================] - 1s 2ms/step - loss: 0.0047 - accuracy: 0.9983 - val_loss: 2.9166e-06 - val_accuracy: 1.0000\n",
      "Epoch 4/4\n",
      "313/313 [==============================] - 1s 2ms/step - loss: 0.0068 - accuracy: 0.9984 - val_loss: 0.0040 - val_accuracy: 0.9980\n"
     ]
    }
   ],
   "source": [
    "# train the model\n",
    "r = model.fit(\n",
    "  [inputs_train, queries_train],\n",
    "  answers_train,\n",
    "  epochs=4,\n",
    "  batch_size=32,\n",
    "  validation_data=([inputs_test, queries_test], answers_test)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check how we weight each input sentence given a story and question\n",
    "debug_model = Model([input_story_, input_question_], story_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# choose a random story\n",
    "story_idx = np.random.choice(len(train_stories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "story:\n",
      "\n",
      "0.99168 \t 0 Sandra went to the garden .\n",
      "0.00003 \t 1 Daniel travelled to the kitchen .\n",
      "0.00075 \t 3 John went to the bedroom .\n",
      "0.00749 \t 4 Daniel went to the hallway .\n",
      "question: Where is Sandra ?\n",
      "answer: garden\n"
     ]
    }
   ],
   "source": [
    "# get weights from debug model\n",
    "i = inputs_train[story_idx:story_idx+1]\n",
    "q = queries_train[story_idx:story_idx+1]\n",
    "w = debug_model.predict([i, q]).flatten()\n",
    "\n",
    "story, question, ans = train_stories[story_idx]\n",
    "print(\"story:\\n\")\n",
    "for i, line in enumerate(story):\n",
    "  print(\"{:1.5f}\".format(w[i]), \"\\t\", \" \".join(line))\n",
    "\n",
    "print(\"question:\", \" \".join(question))\n",
    "print(\"answer:\", ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hit enter to continue\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pause so we can see the output\n",
    "input(\"Hit enter to continue\\n\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inputs_train.shape, inputs_test.shape (10000, 88, 8) (1000, 88, 8)\n"
     ]
    }
   ],
   "source": [
    "##### two supporting facts #####\n",
    "\n",
    "\n",
    "# get the two supporting fact data\n",
    "train_stories, test_stories, \\\n",
    "  inputs_train, queries_train, answers_train, \\\n",
    "  inputs_test, queries_test, answers_test, \\\n",
    "  story_maxsents, story_maxlen, query_maxlen, \\\n",
    "  vocab, vocab_size = get_data('two_supporting_facts_10k')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "##### create the model #####\n",
    "embedding_dim = 30\n",
    "\n",
    "\n",
    "# make a function for this so we can use it again\n",
    "def embed_and_sum(x, axis=2):\n",
    "  x = Embedding(vocab_size, embedding_dim)(x)\n",
    "  x = Lambda(lambda x: K.sum(x, axis))(x)\n",
    "  return x\n",
    "\n",
    "# define the inputs\n",
    "input_story_ = Input((story_maxsents, story_maxlen))\n",
    "input_question_ = Input((query_maxlen,))\n",
    "\n",
    "\n",
    "# embed the inputs\n",
    "embedded_story = embed_and_sum(input_story_)\n",
    "embedded_question = embed_and_sum(input_question_, 1)\n",
    "\n",
    "\n",
    "# final dense will be used in each hop\n",
    "dense_layer = Dense(embedding_dim, activation='elu')\n",
    "\n",
    "\n",
    "def hop(query, story):\n",
    "  # query.shape = (embedding_dim,)\n",
    "  # story.shape = (num sentences, embedding_dim)\n",
    "  x = Reshape((1, embedding_dim))(query) # make it (1, embedding_dim)\n",
    "  x = dot([story, x], 2)\n",
    "  x = Reshape((story_maxsents,))(x) # flatten it for softmax\n",
    "  x = Activation('softmax')(x)\n",
    "  story_weights = Reshape((story_maxsents, 1))(x) # unflatten for dotting\n",
    "\n",
    "  # makes a new embedding\n",
    "  story_embedding2 = embed_and_sum(input_story_)\n",
    "  x = dot([story_weights, story_embedding2], 1)\n",
    "  x = Reshape((embedding_dim,))(x)\n",
    "  x = dense_layer(x)\n",
    "  return x, story_embedding2, story_weights\n",
    "\n",
    "\n",
    "# do the hops\n",
    "ans1, embedded_story, story_weights1 = hop(embedded_question, embedded_story)\n",
    "ans2, _,              story_weights2 = hop(ans1,              embedded_story)\n",
    "\n",
    "# get the final answer\n",
    "ans = Dense(vocab_size, activation='softmax')(ans2)\n",
    "\n",
    "\n",
    "# build the model\n",
    "model2 = Model([input_story_, input_question_], ans)\n",
    "\n",
    "# compile the model\n",
    "model2.compile(\n",
    "  optimizer=RMSprop(lr=5e-3),\n",
    "  loss='sparse_categorical_crossentropy',\n",
    "  metrics=['accuracy']\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/30\n",
      "313/313 [==============================] - 4s 13ms/step - loss: 1.7526 - accuracy: 0.2593 - val_loss: 1.5431 - val_accuracy: 0.3710\n",
      "Epoch 2/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 1.0890 - accuracy: 0.5737 - val_loss: 0.7502 - val_accuracy: 0.7240\n",
      "Epoch 3/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.6553 - accuracy: 0.7558 - val_loss: 0.7166 - val_accuracy: 0.7320\n",
      "Epoch 4/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.5671 - accuracy: 0.7924 - val_loss: 0.6044 - val_accuracy: 0.7630\n",
      "Epoch 5/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.4817 - accuracy: 0.8262 - val_loss: 0.5122 - val_accuracy: 0.7990\n",
      "Epoch 6/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.4090 - accuracy: 0.8586 - val_loss: 0.5055 - val_accuracy: 0.8100\n",
      "Epoch 7/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.3579 - accuracy: 0.8778 - val_loss: 0.4299 - val_accuracy: 0.8360\n",
      "Epoch 8/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.3089 - accuracy: 0.8998 - val_loss: 0.4488 - val_accuracy: 0.8620\n",
      "Epoch 9/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.2799 - accuracy: 0.9119 - val_loss: 0.3323 - val_accuracy: 0.8820\n",
      "Epoch 10/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.2634 - accuracy: 0.9204 - val_loss: 0.3522 - val_accuracy: 0.8860\n",
      "Epoch 11/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.2576 - accuracy: 0.9251 - val_loss: 0.3441 - val_accuracy: 0.8800\n",
      "Epoch 12/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.2291 - accuracy: 0.9308 - val_loss: 0.3564 - val_accuracy: 0.8820\n",
      "Epoch 13/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.2159 - accuracy: 0.9367 - val_loss: 0.4035 - val_accuracy: 0.8750\n",
      "Epoch 14/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.2133 - accuracy: 0.9389 - val_loss: 0.3565 - val_accuracy: 0.8890\n",
      "Epoch 15/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.1919 - accuracy: 0.9443 - val_loss: 0.3556 - val_accuracy: 0.8830\n",
      "Epoch 16/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.1887 - accuracy: 0.9466 - val_loss: 0.3312 - val_accuracy: 0.9010\n",
      "Epoch 17/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.1873 - accuracy: 0.9473 - val_loss: 0.3329 - val_accuracy: 0.9040\n",
      "Epoch 18/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.1675 - accuracy: 0.9529 - val_loss: 0.3765 - val_accuracy: 0.8990\n",
      "Epoch 19/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.1705 - accuracy: 0.9544 - val_loss: 0.4017 - val_accuracy: 0.8950\n",
      "Epoch 20/30\n",
      "313/313 [==============================] - 4s 14ms/step - loss: 0.1661 - accuracy: 0.9515 - val_loss: 0.3065 - val_accuracy: 0.9030\n",
      "Epoch 21/30\n",
      "313/313 [==============================] - 5s 15ms/step - loss: 0.1701 - accuracy: 0.9554 - val_loss: 0.2734 - val_accuracy: 0.9210\n",
      "Epoch 22/30\n",
      "313/313 [==============================] - 4s 14ms/step - loss: 0.1654 - accuracy: 0.9560 - val_loss: 0.4038 - val_accuracy: 0.9100\n",
      "Epoch 23/30\n",
      "313/313 [==============================] - 5s 16ms/step - loss: 0.1581 - accuracy: 0.9582 - val_loss: 0.3568 - val_accuracy: 0.9090\n",
      "Epoch 24/30\n",
      "313/313 [==============================] - 5s 15ms/step - loss: 0.1449 - accuracy: 0.9596 - val_loss: 0.3108 - val_accuracy: 0.9160\n",
      "Epoch 25/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.1467 - accuracy: 0.9616 - val_loss: 0.3318 - val_accuracy: 0.9200\n",
      "Epoch 26/30\n",
      "313/313 [==============================] - 4s 13ms/step - loss: 0.1475 - accuracy: 0.9604 - val_loss: 0.3390 - val_accuracy: 0.9080\n",
      "Epoch 27/30\n",
      "313/313 [==============================] - 4s 13ms/step - loss: 0.1475 - accuracy: 0.9616 - val_loss: 0.2997 - val_accuracy: 0.9210\n",
      "Epoch 28/30\n",
      "313/313 [==============================] - 4s 14ms/step - loss: 0.1499 - accuracy: 0.9619 - val_loss: 0.3401 - val_accuracy: 0.9100\n",
      "Epoch 29/30\n",
      "313/313 [==============================] - 4s 12ms/step - loss: 0.1459 - accuracy: 0.9630 - val_loss: 0.3271 - val_accuracy: 0.9200\n",
      "Epoch 30/30\n",
      "313/313 [==============================] - 4s 13ms/step - loss: 0.1438 - accuracy: 0.9641 - val_loss: 0.3502 - val_accuracy: 0.9080\n"
     ]
    }
   ],
   "source": [
    "# fit the model\n",
    "r = model2.fit(\n",
    "  [inputs_train, queries_train],\n",
    "  answers_train,\n",
    "  epochs=30,\n",
    "  batch_size=32,\n",
    "  validation_data=([inputs_test, queries_test], answers_test)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "story:\n",
      "\n",
      "0.00000 \t 0.00000 \t 0 Sandra went back to the bedroom .\n",
      "0.00000 \t 0.00000 \t 1 John got the apple there .\n",
      "0.00000 \t 0.00000 \t 2 John moved to the office .\n",
      "0.00000 \t 0.00000 \t 3 John left the apple .\n",
      "0.00000 \t 0.00000 \t 5 John grabbed the apple there .\n",
      "0.00000 \t 0.00000 \t 6 Daniel journeyed to the hallway .\n",
      "0.00000 \t 0.00000 \t 7 Mary travelled to the bathroom .\n",
      "0.00000 \t 0.00000 \t 8 Daniel moved to the office .\n",
      "0.00000 \t 0.00000 \t 9 Daniel journeyed to the kitchen .\n",
      "0.00000 \t 0.00000 \t 10 John travelled to the garden .\n",
      "0.00000 \t 0.00001 \t 11 John moved to the bedroom .\n",
      "0.00000 \t 0.00004 \t 12 John went back to the office .\n",
      "0.00022 \t 0.00000 \t 13 John put down the apple .\n",
      "0.00013 \t 0.00000 \t 14 John grabbed the apple there .\n",
      "0.00000 \t 0.00279 \t 15 John moved to the kitchen .\n",
      "0.00000 \t 0.00277 \t 16 John travelled to the office .\n",
      "0.24201 \t 0.00000 \t 18 John dropped the apple .\n",
      "0.00000 \t 0.00000 \t 19 Daniel moved to the office .\n",
      "0.75764 \t 0.00000 \t 21 John grabbed the apple there .\n",
      "0.00000 \t 0.99439 \t 22 John journeyed to the garden .\n",
      "question: Where is the apple ?\n",
      "answer: garden\n",
      "prediction: garden\n"
     ]
    }
   ],
   "source": [
    "### print story line weights again ###\n",
    "debug_model2 = Model(\n",
    "  [input_story_, input_question_],\n",
    "  [story_weights1, story_weights2]\n",
    ")\n",
    "# choose a random story\n",
    "story_idx = np.random.choice(len(train_stories))\n",
    "\n",
    "# get weights from debug model\n",
    "i = inputs_train[story_idx:story_idx+1]\n",
    "q = queries_train[story_idx:story_idx+1]\n",
    "w1, w2 = debug_model2.predict([i, q])\n",
    "w1 = w1.flatten()\n",
    "w2 = w2.flatten()\n",
    "\n",
    "story, question, ans = train_stories[story_idx]\n",
    "print(\"story:\\n\")\n",
    "for j, line in enumerate(story):\n",
    "  print(\"{:1.5f}\".format(w1[j]), \"\\t\", \"{:1.5f}\".format(w2[j]), \"\\t\", \" \".join(line))\n",
    "\n",
    "print(\"question:\", \" \".join(question))\n",
    "print(\"answer:\", ans)\n",
    "print(\"prediction:\", vocab[ np.argmax(model2.predict([i, q])[0]) ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot some data\n",
    "plt.plot(r.history['loss'], label='loss')\n",
    "plt.plot(r.history['val_loss'], label='val_loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAD4CAYAAAATpHZ6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxb5Z3v8c/Psmx5j2M7mx0SJyQkZHFDzFLaAoVCAx0atpZQSrdbMrSX3k57F1qmc0undy7MLdMOHShMpqWFFpoyLIW2AcoeGCgTB0hMEhKSkMVLEjvxbsvW8rt/PLJjO7IjO3Jkyb/366WXdKSjo9+JXvn60XOe5xxRVYwxxqSGtEQXYIwxJn4s1I0xJoVYqBtjTAqxUDfGmBRioW6MMSkkPVEfXFxcrLNnz07UxxtjTFLauHFjo6qWDPV6wkJ99uzZVFVVJerjjTEmKYnI3uFet+4XY4xJIRbqxhiTQizUjTEmhVioG2NMCrFQN8aYFGKhbowxKcRC3RhjUkjCxqkbY0yyUVW6g2G6g2F6gmF6QmG6A6HIfbjffYjuwNH1uoOhAe+rnF3Ix+YNOX/ohFioG2PGTCis+AMhugIhunpCdAdDdPWE8QdDtHcH6egO0u4P0t4dufV/HFnuDobJSE8jMz0Nn9dDZuRxZrqHTO/R5zI8aYQV/MHeQD0apP5A5HHkvicYJqyKKoRV+x6HIo/DYRfgYYVAaGCIx8NN58+1UDfGxE84rLT6AwRCSiisBMPhyH1kud/zwbDS0R2kzd97Cwy4b+33uKMnSFePC/HelutI5GR4yMlMJ9eXTl5mOjmZ6eT50gmE3B+HNn/waFgHwn0B7g+G6L3ej9cj+CKBn5keCfz0NDK9HnzpaeRnecnwCGkSuaWB9D4W8IhElkEEvB63nd4/LBl9f1SiPX/sesc870kjLU3G4Ft1LNSNOcn8gRB7Dnewp7GDps5AXwj23QdC+HtCdPZbDoWVgiwvhdkZTM7xUpiTweTsDHefk0FhtnttUnYGXYEQB1r8HGr1cyByO9TazYEW9/hgq5+Gtm6C4dFf9SxNIDcznTyflzxfOvk+L9MLfOT60snyevB5PWRlePCle8jKcK1pn9fT95rPm+YCOxLgOZnp5GSk4xll2Km6P0hpIqPeRqqwUDdmDITCSl1zF7sbO/igod3dN3awu6GDupYuol1FMk0gOyM9EohpZHk9ZGWkk+VNw+tN42Crn/fqWznS2YM/MLIWcF5mOlMLfEzL9zFnbhHT8n0U5WaS4RE8aWmkp7kwTPcI6Wlp7nGa4PEIHhFyMj19AZ7n85KT4UFk/ISniOD1jJ96EslC3Ux43cEQrV2uC6HVH6S1K0Brb9dC5HFrl/vZHwwpgbASCocJhJRgyHVPBEKu+yIQcl0Ve4900hM8Grx5menMKcnhzNmFlBfPpLwkhznFORTlZpDtTceX4X6WxxqUXT0hmjp7ONLR03ff3BngSEcPWRkepuX7mJKfybR8H1PzfeRk2n/1icK+aZPywmGlvtXPnkhreU9jB3sOu8e1zV3HbfV60oQ8Xzq+dA/pHsHrOdqS9XrSIq1b18L1eYWp+ZlcuGAKc0pyKC/Opbw4h+LcjLi2bLMyPGRlZDFjUlbctmlSg4W6SUrBUJj2yMG71r4Dd0cP2NU2d/UF+OBWs8+bxuyiHOZNyePCBVOYlJ1Bvi+d/Kyj/cP9H2ePs64GY4ZjoW7GpZbOADsb2tl1qJ1dDe3sPNTOviOdfQHe2RMa9v0Z6WnMmpzN7OIcPr5gCrOLcphdnE15cQ5T83xjOvrAmESyUDcJEw4rdS1d7GroYNeh9gEh3tje07dehieN8uIcyotzmJTtHXDAzrWm0495rjA7Y8KPgjATk4W6GXOt/gC7GzrY3dDu7hvd/QeNHXT36xYpyPJy6pRcLlowlblTcphbksupU3IpK8y2gDYmRhbq5oSpKg3t3dQ0dUVunew/0smuBjeEr7G9u29dT5owszCLOSW5fPTUYuaU5DK3JIdTp+QyOSe+BxONmYgs1E1MQmFl+4E2djW09wV3//v+LW6Awmwvc0py+fhpJcwpyWVOSQ5zS3I4ZXIOGel2HrmEa9oLNRvglA9DQWmiq4lOFbpbIRSAnOL4bfNANTTugFkfgfzp8dluKOhqzZ4cn+2dAAt1E1WrP8Db+5rZuLeJt/Y28fa+Jjr6HZwszPZSVpjN/KluBElZYTZlhVmUFWZTWphFro2LHp8adsBrP4bNj4BGvs+pS2D+JTDvk1BWCWmesa8jHIaOQ9BaB2317r731lYHrZHnAh1u/RnLYOHlsPDTUDxv5J93eBdUPwrvPuoCvde0pTD/k27fS8+Ifd9VofF92P0y7H4J9rzmQn3GGf3qPHXkdcaBaLSpbSdBZWWlVlVVJeSzzUCqyt7DnVTtbeoL8R2H2lB1sxwXTMuncnYhy2cVMn9qHmWFWeT5vIku24xE/WZ49Z9g65OQ7oPlX4JFV8L+v8COZ2HfX1zIZ02GeRfDvEvg1Isgq/DEP7u7HQ5ugYPVrpV8oBoOboVg18D10tIhb7q75c9wt7zpEOqB7U9DbSQvShZEgvNyF8pDddm11MC7j7sgr98ECMz+KCy+GqZXwAevwI4/u38DDUN28dF9n3shZE0auL32Q5EQj9xaa93zhbNhzgWQNwN2PAN1b7nnp5x+tM6pi4euc4REZKOqVg75uoX6xOQPhHjt/Uae2XKAl7cf6httkudL54xTXIAvn1VIxcxJ1upOZvv/E9bfCe8/C5n5cOZX4ZyvQ+6gMwR2NcGuF13Ivf9n6DoC4oGZZ7tW/OS5kJ4Jnoyj9/0fp2eCJxOCfhfgBzYfDfAju4FIzvgmwfSl7tfB5PJ+4T0DckogbZiuuZZaeO9PsO0p2PsfLognneJaxQsvh7KzXN1bfw/Vj8G+1937ZpwBS65xf8TyZxy73c4jkX1/FnY+5/4txOO6puZ9AtobXIgf2uLWzyqE8vNdkM+5wO1Hf837I3X+wdWgYRf8vS340srh9/M44hLqIrICuAvwAD9X1TsGvV4I3A/MBfzAV1T13eG2aaF+8nV0B3l5ewPPbDnAi9sO0tETIs+XzoULpnB2eRHLZxUyb0qujeFOdqquFbr+Ttjzqmt9n/N1OOvGY1uf0YRDULvRhdyOZ10LezQKZ8O0Ja41PW2Ju+WXxqfF2tEI29e54Nz1EoQDrqXd1eR+cRSf5oJ88dVQNDf27YZD7lhD774f2uL+WJ1yjgvwuR93+xNrN017w9E6d7/s6sydBuf9D/d9jMIJh7qIeIAdwMVADbABuE5Vt/Zb50dAu6r+QEQWAPeo6kXDbddC/eRo6Qrw4nsHebr6AK/saKA7GKYoJ4NLFk3lk4umce7cYjtwOVLBbug87IKl8/Cgx40Q8MOkmS7Uem+5006odRaT1jrY+zr85V7XVZE7Dc79hutqycwd/XbbDriuh1AAQt1u/0M97tb7uPc+zQNTFsHUReDLj9uuDcvfAu8/50I4f4YL83h1d7QddPvhjcPpGLqa3a+gbU/BaZfBhz43qs3EI9Q/DNymqp+MLH8XQFVv77fOn4DbVfW1yPIu4FxVPTjUdi3Ux044rPyxup7HNtbw+q5GAiFlan4mKxZNY8Xi6Zw5u5B0jwV5TFTdT/3X74aGbdBxGHrahlhZ3E/zdJ87+Ee//1vpPpg0a2DQTy6HgjLX9ZA9eWQh1N0OdW+78K6pci3rtnr32qRT4CN/Ax+6Hry+Ue22Gb+OF+qxdJaWAvv7LdcAZw9aZxNwFfCaiJwFzALKgAGhLiKrgdUAp5xySgwfbUZqc00ztz21hbf2NTNzchZf/kg5KxZP40Nlk6xbZSRUYefzrgtj/18gZ4r7+Z1T7AI4uxiyiyLLRW45a9LRn+XBHmjZD00fQNMedzvygRtKuPc/oKd94Od5Mt3wurxIH3P+dNdV0XvQ0JMB9e8cDfCG91xfLcDkOe4AYGkllC53I0U8dhxkoorlm4+WBIOb93cAd4nIO0A18DYQPOZNqmuANeBa6iMr1Qynsb2bO5/dzu+q9lOUk8mdn6ngqmWlFuQjFQ7De39wI0XqN0HBTLjsTlj2+ZH9BE/PcH250fpzVd3BuaY90FozaDhfvQvtbXWuq2OwrEIX3qevdAFeunxcjI0240csoV4DzOy3XAbU9V9BVVuBLwOImxL4QeRmxlgwFObXf9nLj5/bQVdPiK9+tJxvXDSP/Ik65LCnww0rC4ehZD4UzYOM7OO/LxR0Q99e/TE0bnejPVbeA0s+6wI6nkQgp8jdWB59HVV30K+11o3ZDnS4A3ST58RtaJxJTbGE+gZgnoiUA7XAKmBAD7+ITAI6VbUH+CqwPhL0Zgy9vrOR2/6whR0H2/nYvGK+f/npnDolLz4bD3QNbD323mfkQslpUDzfTQLJyInP550IVXeAcNPDsOX3g7o2xB20LD7taN2999mT3QG+dx6G134CzXvdQb5r7ofTrzg5k3CGIhLp5pnsRo0YE6PjhrqqBkXkZuBZ3JDG+1V1i4jcFHn9PmAh8KCIhICtwH8Zw5onvJqmTv7vum2sqz5AWWEW/3rDci45ferozptyZDds/nfX/9tWH5nJVwv+5mPXzch1Ya/9TntbcIprEfeGZv/AVHXjlrvbIrdWd4Cvd7kncp9T4oKrZIEb7xyrpr2waa0L86Y9rr5FV0DF59znN2x3swcbtrvbnlddPb1yImO1OxpcN8aKO2D+irEfpWLMGLLJR0mkqyfEmvW7ufeVnQB8/YJTWX3eHHzeUbQo2w7C+h/Bxl+6sbm5U46dydd/Ykj+dMjMcy3bw7tcWPYGZuN2N2W6f2BG+wNwPGnpLth7xzRPW+KGpvXvM+5ud0PC3nnYhTQC5ee5kR4L/2r4Xw7hEDTvG1h3dxss/7I7CGrdGiYJ2IzSFOAPhHj4zX387OVdNLZ386ml07n1soWUjuZSZv5WeP2n8MbPXAgv/yKcfwvkTTuxIsNhaNnnzi3SuN3N/svIdn8IMnLdbMbMPDdeOjPPLWfkuhBuOzBwBuKBamg/cHTbBTNduGfkuOnigQ4oLHdBXnGtG8JnzARhoZ7EeoJhHqnaz90v7uRAq59z5kzmv19yGmfOHsVoh4Afqn7hhuh1HYFFV8GF3xvZbLuTqb1h4LlCDlS7CTALPuXC/JRzrGVtJqR4jFM3J1kwFObxt2v56QvvU9PUxfJZhfz4sxWce+ooTj8aDrl+55dvd/3mcz4On/i+G8s8nuWWQO6F7sRKxpiYWaiPI6Gw8odNddz1wvt80NjBktICfnjFYi6YXzLyg6Cqrqvihb93MyFnLIOVd7u+Y2NMyrJQHwfCYeWZLQf4yXM7eP9QOwum5bHmhuVcPNoRLU174Mmb3YHEolPhMw+4ySrWXWFMyrNQT7CGtm5u+s1GNu5tYm5JDnd/bhmXLZ4+upmgqvD2b+CZ74Ckwad+DGd8ATwTdCKSMROQhXoC7TzUxpd+uYHG9m7+39VLuXp52egvsNzeAH/4Jmz/E8z+GFzxMxsVYswEZKGeIG/sOsxf/7qKjHQPv1v9YSpmxnCe66Fsfxqe+oY7Bekl/+DOnW0TaIyZkCzUE+Dxt2q45bHNzCrK4ZdfOpOZk2M4N0k03e3w7K3w1gPuSjJfeNKdx9oYM2FZqJ9EqspPX9jJT57fwblzi7j388spyBplf/e+N+GJ1W6q/Ef+Bj5+68im2BtjUpKF+knSEwzz3cereeytGq4+o4zbr1oyuisOBXvglTvcCagKyuDL62DWufEv2BiTlCzUT4KWrgA3/Xojb+w+zLcvns83Ljx1dEMVD73nWuf1m+BDn4cVt5+8S4YZY5KChfoY23+kk6/8agN7Dnfw489WcNUZZSPfSDgM//mv8Nz33blTrv2NuzK5McYMYqE+hjbXNPOVX1XREwzx4FfO5sNzi0a+kZZa+P3X3NXh56+Ay38KeVPjX6wxJiVYqI+RF7Yd5OaH36YoN4O1q88e3cUrqh+FP33bXZXn8rvgjC/arFBjzLAs1MfAIxv2890nqlk0I59ffPFMSvJGOCql8wis+x/w7mNQdhZced/4PZuiMWZcsVCPI1XlZy/v4kfPbue8+SXce/0Z5GSO8J9414vw+6+7q/Fc+D34yLfsyvDGmJhZWsRJKKz8/R+28MAbe7lyWSn/ePXSkQ1Z7OmE529zB0SLT4Prfjv+T49rjBl3LNTjoDsY4tu/28Sfquu58WPlfPfShbGfkCschn2vwx+/5S6zdvbX3PnOvaO4qpExZsKLKdRFZAVwF+7C0z9X1TsGvV4A/AY4JbLNO1X1l3GudVxq9Qf46wfdGPS/vWwhN5435/hv8rfC7pdgx5/h/T9DxyF3HdAbfg9zPz72RRtjUtZxQ11EPMA9wMVADbBBRJ5S1a39VvuvwFZVvVxESoDtIvKQqvaMSdXjxKE2P1+6fwM7Drbxk2sruHLZMGPQG3fC+8/Cjmdg7xsQDoCvAOZe5IYqnnapTSQyxpywWFrqZwE7VXU3gIisBVYC/UNdgTxx0yRzgSNAMM61jisfNHbwhfvf5HB7D7/40pmcP79k4Aqqbmz59mdcmB/Z7Z4vWQgf/jrM+yTMPNsOghpj4iqWRCkF9vdbrgHOHrTO3cBTQB2QB1yrquHBGxKR1cBqgFNOSd5zfW+uaebLv9yAAr+98ZxjT5sbCrpT4W56GDyZUH6eOx3uvEugcFZCajbGTAyxhHq0I346aPmTwDvAhcBc4DkReVVVWwe8SXUNsAagsrJy8DaSwvodDdz0m41Mzsngwa+cxZyS3IErhALw+I2w5Qk4/xZ3BsWMUZ5a1xhjRiiWMXc1wMx+y2W4Fnl/XwYeV2cn8AGwID4ljh/PbT3IVx+oYlZRDo9/7dxjAz3YDY98wQX6xT90p8O1QDfGnESxhPoGYJ6IlItIBrAK19XS3z7gIgARmQqcBuyOZ6GJ9nR1PV/7zUYWzshn7epzmJLvG7hCTyf8dhVsXweX3Qkf+W+JKdQYM6Edt/tFVYMicjPwLG5I4/2qukVEboq8fh/wQ+BXIlKN6665RVUbx7Duk+oPm+r4m9+9Q0VZAb/6ylnk+wZd2KK7DX57Hex5DT59N5xxQ2IKNcZMeDENvVDVdcC6Qc/d1+9xHXBJfEsbH554u4b//sgmKmdN5v4vn0nu4Gn/Xc3w0GegdiNc/XNYck1iCjXGGGxG6bD+vWo//+uxzZxTXsQvvlRJdsagf67OI/DrK+DgVvjMr+D0TyekTmOM6WWhPoSH39zHrU9U87F5xay5oZKsDM/AFdoPwYMr4fAuWPUwzE/JHyrGmCRjoR7Fg2/s4X8/uYWPn1bCvZ9fjs87KNBbauHBT0NrHVz/CMy5IAFVGmPMsSzUB/nFax/wwz9u5RMLp3LP9cvITB8U6E174IFPu66Xzz8Osz6ckDqNMSYaC/V+/vWVXdz+9Htcungad61aduypc2s3wm8/B0E/fPFJKF2emEKNMWYIIzjhd2q7+8X3uf3p97i8Ygb/cl2UQK9+FH55GaRnwJeftkA3xoxL1lIHXtnRwJ1/3sGVy0r50TVLSff0C/RwGF7+v7D+R3DKuXDtryGnOHHFGmPMMCzUgTd2HcbrEW6/asnAQO9uhyf+Gt77Iyy7AT71Y9dSN8aYccpCHaiubWbBtPyBo1ya97n+80NbYMUdcPZNIDFezcgYYxJkwod6OKxsrmnh0xUzjj6570343fUQ7IHr/x1O/UTiCjTGmBGY8AdK9x7ppM0fZGlZgXvi7Yfggb+CzDz46vMW6MaYpDLhW+qba5oBWDojD/78PXj9X6D8fDftP3tyYoszxpgRmvChvmXvQT7i3c5pL/0Sdj4HZ94IK24Hj/f4bzbGmHFmYoV6OAyN26Gmyk0kqq3ilgNb8HjCsDsdPvVPcOZXE12lMcaMWmqHelezO8d5JMCpfRt62txrmQWES8/g38IrKZj3Ya676mobf26MSXqpHeq/ucoFelo6TF0MFde6maCllVB0KjsOtXPH1lf5yeIKC3RjTEpI7VBvfB+WroLL/xm8Wce8vLmmBYClZZNOdmXGGDMmUndIY3c7dLfClAVRAx3cyJe8zHTKi3JOcnHGGDM2UjfU2+rdfd6MIVeprmlhcWkBaWk2U9QYkxpiCnURWSEi20Vkp4h8J8rr/1NE3onc3hWRkIgkdpB3a527z48e6j3BMNvq21g6s+AkFmWMMWPruKEuIh7gHuBS4HTgOhE5vf86qvojVf2Qqn4I+C7wiqoeGYuCY3acUH/vQCs9oTBLS60/3RiTOmJpqZ8F7FTV3araA6wFVg6z/nXAb+NR3Alpi4R63vSoLx89SGotdWNM6ogl1EuB/f2WayLPHUNEsoEVwGNDvL5aRKpEpKqhoWGktY5Maz34CiAjO+rLm2uaKcz2UlYY/SCqMcYko1hCPdpRRB1i3cuB/xiq60VV16hqpapWlpSUxFrj6LTVD3uQdHNNC0vLJiF2Ol1jTAqJJdRrgJn9lsuAuiHWXcV46HoB16eeH73rpasnxI6DbVRY14sxJsXEEuobgHkiUi4iGbjgfmrwSiJSAJwPPBnfEkdpmJb6lroWwgpLbNKRMSbFHHdGqaoGReRm4FnAA9yvqltE5KbI6/dFVr0S+LOqdoxZtbEKBaH94JAtdTtIaoxJVTGdJkBV1wHrBj1336DlXwG/ildhJ6TjEGh4yOGMm2uamZqfydR830kuzBhjxlZqzijtHaM+RPdL70FSY4xJNakd6lG6X1r9AXY3dthBUmNMSkrNUB/mvC/vRvrT7SCpMSYVpWaot9ZBmheyi455aVPvQdJSa6kbY1JPaoZ6W707PUDasbtXXdvMzMlZFOZkJKAwY4wZW6kZ6sNMPNq03w6SGmNSV2qGelt91OGMh9u7qW3usoOkxpiUlXqhrupa6lEOkm6ujRwktdPtGmNSVOqFur8FAp1Ru182729BBBaX5iegMGOMGXupF+p9wxmPDfXq2mbmFOeQ5/Oe5KKMMebkSL1QH+KKR6rKppoWKuwgqTEmhaVeqA/RUj/Y2k1DW7edxMsYk9JSL9Rbo4f6pppmwGaSGmNSW+qFelsdZE0G78AzMG6uacaTJiyaYQdJjTGpK/VCvbUO8o+9hOrmmhbmT83D5/UkoChjjDk5UjTUB3a9qCrVtS026cgYk/JSL9R7z/vSz74jnTR3Buz0AMaYlJdaoR7sgY6GY4Yz2uXrjDETRWqFevsBdz+opb65ppmM9DTmT81LQFHGGHPyxBTqIrJCRLaLyE4R+c4Q61wgIu+IyBYReSW+ZcaodzhjlJb6wun5ZKSn1t8wY4wZ7LgpJyIe4B7gUuB04DoROX3QOpOAnwGfVtVFwGfGoNbja+u9NunRlnoorLxrB0mNMRNELE3Xs4CdqrpbVXuAtcDKQet8DnhcVfcBqOqh+JYZoyinCNjd0E5HT8gOkhpjJoRYQr0U2N9vuSbyXH/zgUIReVlENorIF6JtSERWi0iViFQ1NDSMruLhtNZBug+yCvuesoOkxpiJJJZQlyjP6aDldGA58Cngk8Dficj8Y96kukZVK1W1sqSkZMTFHlfvcEY5WvLmmmayMzzMLcmN/+cZY8w4kx7DOjXAzH7LZUBdlHUaVbUD6BCR9UAFsCMuVcaq9dgrHm2qaWHxjAI8adH+NhljTGqJpaW+AZgnIuUikgGsAp4atM6TwMdEJF1EsoGzgW3xLTUGbXUDDpIGQmG21rda14sxZsI4bktdVYMicjPwLOAB7lfVLSJyU+T1+1R1m4g8A2wGwsDPVfXdsSw8SqGupb7waKhvP9BGTzDM0pl2kNQYMzHE0v2Cqq4D1g167r5Byz8CfhS/0kaoqwlC3QOuTVoduSbp0lJrqRtjJobUmY3TN5zxaEt9c00z+b50ZhVlJ6goY4w5uVIw1I+OtqyubWFp2SRE7CCpMWZiSJ1QjzKbdO/hTuaU5CSoIGOMOflSJ9Rb6wGBvGlu0R+gzR9kxqSsxNZljDEnUeqEelsd5JSAxwtAXXMXAKUW6saYCSR1Qr21fsBB0t5Qt5a6MWYiSZ1Qb6sfMJyxttkPQFmhhboxZuJInVAfdG3S2qYuvB6hJDczgUUZY8zJlRqhHuiCriMDzvtS19zF9IIs0uycL8aYCSQ1Qr0tcsWjAd0vXcyY5EtQQcYYkxipEep9l7EbeKC0dJLNJDXGTCypEeqDWuqBUJiDrX5KraVujJlgUiPUB5335UCLn7BCqY18McZMMKkR6m314M2BzHzA9aeDjVE3xkw8qRHqvcMZIyfusolHxpiJKnVCPW/gGHWwUwQYYyae1Aj1tvoBp9yta+miKCcDn9eTwKKMMebkS/5QD4cjoX60pV7T1GUHSY0xE1Lyh3pnI4SDAyYe1TV3MaPAQt0YM/HEFOoiskJEtovIThH5TpTXLxCRFhF5J3L73/EvdQiDhjOqKrXN1lI3xkxMx73wtIh4gHuAi4EaYIOIPKWqWwet+qqq/tUY1Di8QROPmjoD+ANhG/lijJmQYmmpnwXsVNXdqtoDrAVWjm1ZIzCopW4XxzDGTGSxhHopsL/fck3kucE+LCKbRORpEVkUbUMislpEqkSkqqGhYRTlRtFaB5IGOVNccTac0RgzgcUS6tHOXauDlt8CZqlqBfAvwO+jbUhV16hqpapWlpSUjKzSobTVQ+408LiepL6WuvWpG2MmoFhCvQaY2W+5DKjrv4Kqtqpqe+TxOsArIsVxq3I4gy+O0dyFz5tGYbb3pHy8McaMJ7GE+gZgnoiUi0gGsAp4qv8KIjJNxM3RF5GzIts9HO9io2qrHzCb1J1yN4tIOcYYM6Ecd/SLqgZF5GbgWcAD3K+qW0Tkpsjr9wHXAF8TkSDQBaxS1cFdNGOjtR7Kz+tbdBfHsK4XY8zEdNxQh74ulXWDnruv3+O7gbvjW1oMejqgu+WYlvqiGfknvRRjjBkPkntGad8Vj9wYdX8gRGN7j80mNcZMWMkd6m2R47V5g8ao28gXY8wEldyh3jfxyA2bt4tjGGMmuhQJdZtNaowxkOyh3lYPmQWQkQO4i2OkCUwrsAtOG2MmpoEUVn8AAA2YSURBVOQO9WMmHvmZmu/D60nu3TLGmNFK7vSLMvHI+tONMRNZcod6a33fcEawiUfGGJO8oR4KQvvBvpZ6OKzUt3TZQVJjzISWvKHecQg01Nen3tDeTSCklE6yg6TGmIkreUO9bzbpwDHqNvHIGDORJW+oD5pNWttkE4+MMSZ5Q33QeV9s4pExxiRzqLfVQZoXst21OGqbu8jzpZPns4tjGGMmruQN9dZ6yJsGaW4Xei+OYYwxE1nyhnpb3YCJRzVNFurGGJO8oT7oFAF1zV028sUYM+ElZ6irRmaTuuGMbf4Arf6gjXwxxkx4yRnq3a0Q6Oh3cQw/YCNfjDEmplAXkRUisl1EdorId4ZZ70wRCYnINfErMYpBwxlrmzsBG6NujDHHDXUR8QD3AJcCpwPXicjpQ6z3j8Cz8S7yGIMnHkVa6mXWp26MmeBiaamfBexU1d2q2gOsBVZGWe8bwGPAoTjWF11fS/3oFY+8HqEkN3PMP9oYY8azWEK9FNjfb7km8lwfESkFrgTuG25DIrJaRKpEpKqhoWGktR4V5RQB0wuySEuT0W/TGGNSQCyhHi0pddDyPwO3qGpouA2p6hpVrVTVypKSklhrPFZrHWQVgtd1t7iLY9jZGY0xJj2GdWqAmf2Wy4C6QetUAmtFBKAYuExEgqr6+7hUOVhrPeQNvDjGuXOLx+SjjDEmmcQS6huAeSJSDtQCq4DP9V9BVct7H4vIr4A/jlmgg+t+iYx8CYTCHGz123nUjTGGGLpfVDUI3Iwb1bINeERVt4jITSJy01gXGFVrfd9B0gMtfsJq51E3xhiIraWOqq4D1g16LupBUVX90omXNYxQADoa+rpfek+5a2PUjTEmGWeUth0AtK+lXmuhbowxfZIw1CNj1PPs4hjGGDNY8oV6a2TgTb+WelFOBj6vJ4FFGWPM+JB8oV52Jlz1cyh0A25qm/12kNQYYyKSL9QLSmHpZyAzF4Dapk5mFFioG2MMxDj6ZbxSVeqa/Vxw2pREl2KMGaFAIEBNTQ1+vz/RpYxLPp+PsrIyvN6RXXc5qUO9uTNAVyBkI1+MSUI1NTXk5eUxe/ZsIrPRTYSqcvjwYWpqaigvLz/+G/pJvu6Xfmpt5IsxScvv91NUVGSBHoWIUFRUNKpfMRbqxpiEsUAf2mj/bZI71JsioW6jX4wxBkjyUK9r7sLnTaMwe2QHEowxJlUldajXNndROinLfsIZY0xEUo9+cRfHsK4XY5LdD/6wha11rXHd5ukz8vn+5YuOu94VV1zB/v378fv9fPOb32T16tU888wz3HrrrYRCIYqLi3nhhRdob2/nG9/4BlVVVYgI3//+97n66qvjWnM8JHWo1zZ3cfqM/ESXYYxJYvfffz+TJ0+mq6uLM888k5UrV3LjjTeyfv16ysvLOXLkCAA//OEPKSgooLq6GoCmpqZElj2kpA11fyBEY3uPzSY1JgXE0qIeKz/96U954oknANi/fz9r1qzhvPPO6xsfPnnyZACef/551q5d2/e+wsLCk19sDJK2T73v7Iw28sUYM0ovv/wyzz//PG+88QabNm1i2bJlVFRURD1Op6pJcfwuiUPdDcq3PnVjzGi1tLRQWFhIdnY27733Hn/5y1/o7u7mlVde4YMPPgDo63655JJLuPvuu/veO167X5I21GubOwGbeGSMGb0VK1YQDAZZunQpf/d3f8c555xDSUkJa9as4aqrrqKiooJrr70WgO9973s0NTWxePFiKioqeOmllxJcfXRJ26de2+wnTWBagV1w2hgzOpmZmTz99NNRX7v00ksHLOfm5vLAAw+cjLJOSEwtdRFZISLbRWSniHwnyusrRWSziLwjIlUi8tH4lzpQbVMXU/N9eD1J+2PDGGPi7rgtdRHxAPcAFwM1wAYReUpVt/Zb7QXgKVVVEVkKPAIsGIuCe9kYdWOMOVYszdyzgJ2qultVe4C1wMr+K6hqu6pqZDEHUMZYXYuFujHGDBZLqJcC+/st10SeG0BErhSR94A/AV+JT3nRhcNKfbPfDpIaY8wgsYR6tIGZx7TEVfUJVV0AXAH8MOqGRFZH+tyrGhoaRlZpP43t3fSEwpROsoOkxhjTXyyhXgPM7LdcBtQNtbKqrgfmikhxlNfWqGqlqlaWlJSMuNi+gmzikTHGRBVLqG8A5olIuYhkAKuAp/qvICKnSmSqlYicAWQAh+NdbK/e2aTWp26MMQMdd/SLqgZF5GbgWcAD3K+qW0Tkpsjr9wFXA18QkQDQBVzb78Bp3PVdHMNC3RhzkuTm5tLe3p7oMo4rpslHqroOWDfoufv6Pf5H4B/jW9rQ6pq7yPOlk+ezi2MYkxKe/g4cqI7vNqctgUvviO82k0BSztzpvTiGMcaM1i233MLPfvazvuXbbruNH/zgB1x00UWcccYZLFmyhCeffDKmbbW3tw/5vgcffJClS5dSUVHBDTfcAMDBgwe58sorqaiooKKigtdffz1+O6aqCbktX75cR2vFP6/Xr/zyP0f9fmNM4m3dujWhn//WW2/peeed17e8cOFC3bt3r7a0tKiqakNDg86dO1fD4bCqqubk5Ay5rUAgEPV97777rs6fP18bGhpUVfXw4cOqqvrZz35Wf/KTn6iqajAY1Obm5qjbjfZvBFTpMNmalOd+qW3q5MzZ4/NcxsaY5LBs2TIOHTpEXV0dDQ0NFBYWMn36dL71rW+xfv160tLSqK2t5eDBg0ybNm3Ybakqt9566zHve/HFF7nmmmsoLnaDAXvPzf7iiy/y4IMPAuDxeCgoKIjbfiVdqLf5A7T6gzbyxRhzwq655hoeffRRDhw4wKpVq3jooYdoaGhg48aNeL1eZs+ejd/vP+52hnqfJuAc7EnXp957HnXrUzfGnKhVq1axdu1aHn30Ua655hpaWlqYMmUKXq+Xl156ib1798a0naHed9FFF/HII49w+LAb4d17bvaLLrqIe++9F4BQKERra/yuz5qEoW5j1I0x8bFo0SLa2tooLS1l+vTpXH/99VRVVVFZWclDDz3EggWxnZdwqPctWrSIv/3bv+X888+noqKCb3/72wDcddddvPTSSyxZsoTly5ezZcuWuO2T6NgNJx9WZWWlVlVVjfh9VXuO8G+v7ub/XLGEkrzMMajMGHMybNu2jYULFya6jHEt2r+RiGxU1cqh3pN0feqVsydTOXtyosswxphxKelC3RhjEqW6urpvrHmvzMxM3nzzzQRVdCwLdWNMwiRidMiJWLJkCe+8885J+azRdo0n3YFSY0xq8Pl8HD58eNThlcpUlcOHD+Pzjfz04tZSN8YkRFlZGTU1NZzItRVSmc/no6ysbMTvs1A3xiSE1+ulvLw80WWkHOt+McaYFGKhbowxKcRC3RhjUkjCZpSKSAMQ24kVjlUMNMaxnPEg1fYp1fYHUm+fUm1/IPX2Kdr+zFLVIS/ynLBQPxEiUjXcNNlklGr7lGr7A6m3T6m2P5B6+zSa/bHuF2OMSSEW6sYYk0KSNdTXJLqAMZBq+5Rq+wOpt0+ptj+Qevs04v1Jyj51Y4wx0SVrS90YY0wUFurGGJNCki7URWSFiGwXkZ0i8p1E1xMPIrJHRKpF5B0RGfnloBJMRO4XkUMi8m6/5yaLyHMi8n7kvjCRNY7UEPt0m4jURr6nd0TkskTWOBIiMlNEXhKRbSKyRUS+GXk+Kb+nYfYnmb8jn4j8p4hsiuzTDyLPj+g7Sqo+dRHxADuAi4EaYANwnapuTWhhJ0hE9gCVqpqUkyZE5DygHXhQVRdHnvt/wBFVvSPyx7dQVW9JZJ0jMcQ+3Qa0q+qdiaxtNERkOjBdVd8SkTxgI3AF8CWS8HsaZn8+S/J+RwLkqGq7iHiB14BvAlcxgu8o2VrqZwE7VXW3qvYAa4GVCa5pwlPV9cCRQU+vBB6IPH4A9x8uaQyxT0lLVetV9a3I4zZgG1BKkn5Pw+xP0lKnPbLojdyUEX5HyRbqpcD+fss1JPkXGaHAn0Vko4isTnQxcTJVVevB/QcEpiS4nni5WUQ2R7pnkqKrYjARmQ0sA94kBb6nQfsDSfwdiYhHRN4BDgHPqeqIv6NkC/Vo171Knv6joX1EVc8ALgX+a+Snvxl/7gXmAh8C6oF/Smw5IyciucBjwN+oamui6zlRUfYnqb8jVQ2p6oeAMuAsEVk80m0kW6jXADP7LZcBdQmqJW5UtS5yfwh4AtfNlOwORvo9e/s/DyW4nhOmqgcj/+nCwL+RZN9TpJ/2MeAhVX088nTSfk/R9ifZv6NeqtoMvAysYITfUbKF+gZgnoiUi0gGsAp4KsE1nRARyYkc6EFEcoBLgHeHf1dSeAr4YuTxF4EnE1hLXPT+x4q4kiT6niIH4X4BbFPVH/d7KSm/p6H2J8m/oxIRmRR5nAV8AniPEX5HSTX6BSAyROmfAQ9wv6r+Q4JLOiEiMgfXOgd3ecGHk22fROS3wAW404QeBL4P/B54BDgF2Ad8RlWT5sDjEPt0Ae5nvQJ7gL/u7esc70Tko8CrQDUQjjx9K64fOum+p2H25zqS9ztaijsQ6sE1uB9R1b8XkSJG8B0lXagbY4wZWrJ1vxhjjBmGhboxxqQQC3VjjEkhFurGGJNCLNSNMSaFWKgbY0wKsVA3xpgU8v8B4//QpRaG8KAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# accuracies\n",
    "plt.plot(r.history['accuracy'], label='acc')\n",
    "plt.plot(r.history['val_accuracy'], label='val_acc')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}