QA_Single_Supporting_Fact.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training a QA model using Facebook's Babi Dataset for Single Supporting Fact.\n",
    "\n",
    "1. Read and parse the stories in the bAbi task format from the downloaded file.\n",
    "2. Vectorize the Story, Query and Answer and add padding.\n",
    "3. Embedd the Input Sequence and Question into a sequence of vectors.\n",
    "4. After all RNN is used.\n",
    "5. RMSProp optimizer is used and loss function is categorical_crossentropy.\n",
    "6. Model is fit on the training and validation context, question and answers.\n",
    "7. We pass in plot callbacks to see how training cost and validation cost varies as the\n",
    "   number of epochs increases.\n",
    "8. Model is saved and then loaded and our test examples are vectorized and passed to the\n",
    "   model to predict the answer for the question.\n",
    "\n",
    "#### Below is an example:\n",
    "\n",
    "\n",
    "**Story:** Daniel went back to the hallway .\n",
    "Mary went back to the office .\n",
    "\n",
    "**Question:** Where is Mary ?\n",
    "\n",
    "**Original Ans:** office\n",
    "\n",
    "**Predicted Ans:** office\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import keras\n",
    "from keras.models import Sequential, Model\n",
    "from keras.layers.embeddings import Embedding\n",
    "from keras.layers import Input, Activation, Dense, Permute, Dropout\n",
    "from keras.layers import add, dot, concatenate\n",
    "from keras.layers import LSTM\n",
    "from keras.utils.data_utils import get_file\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from functools import reduce\n",
    "import tarfile\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import re\n",
    "from matplotlib import pyplot as plt\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize(sent):\n",
    "    '''Return the tokens of a sentence including punctuation.\n",
    "    >>> tokenize('Bob dropped the apple. Where is the apple?')\n",
    "    ['Bob', 'dropped', 'the', 'apple', '.', 'Where', 'is', 'the', 'apple', '?']\n",
    "    '''\n",
    "    return [x.strip() for x in re.split('(\\W+)?', sent) if x.strip()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_stories(f, only_supporting=False, max_length=None):\n",
    "    '''Given a file name, read the file,\n",
    "    retrieve the stories,\n",
    "    and then convert the sentences into a single story.\n",
    "    If max_length is supplied,\n",
    "    any stories longer than max_length tokens will be discarded.\n",
    "    '''\n",
    "    data = parse_stories(f.readlines(), only_supporting=only_supporting)\n",
    "    flatten = lambda data: reduce(lambda x, y: x + y, data)\n",
    "    data = [(flatten(story), q, answer) for story, q, answer in data if not max_length or len(flatten(story)) < max_length]\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_stories(lines, only_supporting=False):\n",
    "    '''Parse stories provided in the bAbi tasks format\n",
    "    If only_supporting is true, only the sentences\n",
    "    that support the answer are kept.\n",
    "    '''\n",
    "    data = []\n",
    "    story = []\n",
    "    for line in lines:\n",
    "        line = line.decode('utf-8').strip()\n",
    "        nid, line = line.split(' ', 1)\n",
    "        nid = int(nid)\n",
    "        if nid == 1:\n",
    "            story = []\n",
    "        if '\\t' in line:\n",
    "            q, a, supporting = line.split('\\t')\n",
    "            q = tokenize(q)\n",
    "            substory = None\n",
    "            if only_supporting:\n",
    "                # Only select the related substory\n",
    "                supporting = map(int, supporting.split())\n",
    "                substory = [story[i - 1] for i in supporting]\n",
    "            else:\n",
    "                # Provide all the substories\n",
    "                substory = [x for x in story if x]\n",
    "            data.append((substory, q, a))\n",
    "            story.append('')\n",
    "        else:\n",
    "            sent = tokenize(line)\n",
    "            story.append(sent)\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vectorize_stories(data, word_idx, story_maxlen, query_maxlen):\n",
    "    X = []\n",
    "    Xq = []\n",
    "    Y = []\n",
    "    for story, query, answer in data:\n",
    "        x = [word_idx[w] for w in story]\n",
    "        xq = [word_idx[w] for w in query]\n",
    "        # let's not forget that index 0 is reserved\n",
    "        y = np.zeros(len(word_idx) + 1)\n",
    "        y[word_idx[answer]] = 1\n",
    "        X.append(x)\n",
    "        Xq.append(xq)\n",
    "        Y.append(y)\n",
    "    return (pad_sequences(X, maxlen=story_maxlen),\n",
    "            pad_sequences(Xq, maxlen=query_maxlen), np.array(Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PlotLearning(keras.callbacks.Callback):\n",
    "    '''Plot a Live chart for loss/val_loss vs epochs and \n",
    "    accuracy/validation_accuracy vs epochs while the model\n",
    "    is training\n",
    "    '''\n",
    "    def on_train_begin(self, logs={}):\n",
    "        self.i = 0\n",
    "        self.x = []\n",
    "        self.losses = []\n",
    "        self.val_losses = []\n",
    "        self.acc = []\n",
    "        self.val_acc = []\n",
    "        self.fig = plt.figure()\n",
    "        \n",
    "        self.logs = []\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        self.logs.append(logs)\n",
    "        self.x.append(self.i)\n",
    "        self.losses.append(logs.get('loss'))\n",
    "        self.val_losses.append(logs.get('val_loss'))\n",
    "        self.acc.append(logs.get('acc'))\n",
    "        self.val_acc.append(logs.get('val_acc'))\n",
    "        self.i += 1\n",
    "        f, (ax1, ax2) = plt.subplots(1, 2, sharex=True)\n",
    "        \n",
    "        clear_output(wait=True)\n",
    "        \n",
    "        ax1.set_yscale('log')\n",
    "        ax1.plot(self.x, self.losses, label=\"loss\")\n",
    "        ax1.plot(self.x, self.val_losses, label=\"val_loss\")\n",
    "        ax1.legend()\n",
    "        \n",
    "        ax2.plot(self.x, self.acc, label=\"accuracy\")\n",
    "        ax2.plot(self.x, self.val_acc, label=\"validation accuracy\")\n",
    "        ax2.legend()\n",
    "        \n",
    "        plt.show();\n",
    "        \n",
    "plot = PlotLearning()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download babi dataset\n",
    "try:\n",
    "    path = get_file('babi-tasks-v1-2.tar.gz', origin='https://s3.amazonaws.com/text-datasets/babi_tasks_1-20_v1-2.tar.gz')\n",
    "except:\n",
    "    print('Error downloading dataset, please download it manually:\\n'\n",
    "          '$ wget http://www.thespermwhale.com/jaseweston/babi/tasks_1-20_v1-2.tar.gz\\n'\n",
    "          '$ mv tasks_1-20_v1-2.tar.gz ~/.keras/datasets/babi-tasks-v1-2.tar.gz')\n",
    "    raise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "tar = tarfile.open(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting stories for the challenge: single_supporting_fact_10k\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\surinder.kumar01\\AppData\\Local\\conda\\conda\\envs\\tia\\lib\\re.py:212: FutureWarning: split() requires a non-empty pattern match.\n",
      "  return _compile(pattern, flags).split(string, maxsplit)\n"
     ]
    }
   ],
   "source": [
    "challenge_type = 'single_supporting_fact_10k'\n",
    "challenge = challenges[challenge_type]\n",
    "\n",
    "print('Extracting stories for the challenge:', challenge_type)\n",
    "train_stories = get_stories(tar.extractfile(challenge.format('train')))\n",
    "test_stories = get_stories(tar.extractfile(challenge.format('test')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a Vocabulary from the training and test stories dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab = set()\n",
    "for story, q, answer in train_stories + test_stories:\n",
    "    vocab |= set(story + q + [answer])\n",
    "vocab = sorted(vocab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reserve 0 for masking via pad_sequences\n",
    "vocab_size = len(vocab) + 1\n",
    "story_maxlen = max(map(len, (x for x, _, _ in train_stories + test_stories)))\n",
    "query_maxlen = max(map(len, (x for _, x, _ in train_stories + test_stories)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocab size: 22 unique words\n",
      "Story max length: 68 words\n",
      "Query max length: 4 words\n",
      "Number of training stories: 10000\n",
      "Number of test stories: 1000\n",
      "-\n",
      "Here's what a \"story\" tuple looks like (input, query, answer):\n",
      "(['Mary', 'moved', 'to', 'the', 'bathroom', '.', 'John', 'went', 'to', 'the', 'hallway', '.', 'Daniel', 'went', 'back', 'to', 'the', 'hallway', '.', 'Sandra', 'moved', 'to', 'the', 'garden', '.'], ['Where', 'is', 'Daniel', '?'], 'hallway')\n",
      "-\n"
     ]
    }
   ],
   "source": [
    "print('Vocab size:', vocab_size, 'unique words')\n",
    "print('Story max length:', story_maxlen, 'words')\n",
    "print('Query max length:', query_maxlen, 'words')\n",
    "print('Number of training stories:', len(train_stories))\n",
    "print('Number of test stories:', len(test_stories))\n",
    "print('-')\n",
    "print('Here\\'s what a \"story\" tuple looks like (input, query, answer):')\n",
    "print(train_stories[1])\n",
    "print('-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vectorizing the word sequences...\n"
     ]
    }
   ],
   "source": [
    "print('Vectorizing the word sequences...')\n",
    "\n",
    "word_idx = dict((c, i + 1) for i, c in enumerate(vocab))\n",
    "\n",
    "inputs_train, queries_train, answers_train = vectorize_stories(train_stories,\n",
    "                                                               word_idx,\n",
    "                                                               story_maxlen,\n",
    "                                                               query_maxlen)\n",
    "inputs_test, queries_test, answers_test = vectorize_stories(test_stories,\n",
    "                                                            word_idx,\n",
    "                                                            story_maxlen,\n",
    "                                                            query_maxlen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reverse the dictionary for mapping output idx to vocabulary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_dict = {v: k for k, v in word_idx.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inputs: integer tensor of shape (samples, max_length)\n",
      "inputs_train shape: (10000, 68)\n",
      "inputs_test shape: (1000, 68)\n",
      "-\n",
      "queries: integer tensor of shape (samples, max_length)\n",
      "queries_train shape: (10000, 4)\n",
      "queries_test shape: (1000, 4)\n",
      "-\n",
      "answers: binary (1 or 0) tensor of shape (samples, vocab_size)\n",
      "answers_train shape: (10000, 22)\n",
      "answers_test shape: (1000, 22)\n",
      "-\n",
      "Compiling...\n"
     ]
    }
   ],
   "source": [
    "print('inputs: integer tensor of shape (samples, max_length)')\n",
    "print('inputs_train shape:', inputs_train.shape)\n",
    "print('inputs_test shape:', inputs_test.shape)\n",
    "print('-')\n",
    "print('queries: integer tensor of shape (samples, max_length)')\n",
    "print('queries_train shape:', queries_train.shape)\n",
    "print('queries_test shape:', queries_test.shape)\n",
    "print('-')\n",
    "print('answers: binary (1 or 0) tensor of shape (samples, vocab_size)')\n",
    "print('answers_train shape:', answers_train.shape)\n",
    "print('answers_test shape:', answers_test.shape)\n",
    "print('-')\n",
    "print('Compiling...')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define placeholder for input sequence and question"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_sequence = Input((story_maxlen,))\n",
    "question = Input((query_maxlen,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# encoders\n",
    "# embed the input sequence into a sequence of vectors\n",
    "input_encoder_m = Sequential()\n",
    "input_encoder_m.add(Embedding(input_dim=vocab_size,\n",
    "                              output_dim=64))\n",
    "input_encoder_m.add(Dropout(0.3))\n",
    "# output: (samples, story_maxlen, embedding_dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# embed the input into a sequence of vectors of size query_maxlen\n",
    "input_encoder_c = Sequential()\n",
    "input_encoder_c.add(Embedding(input_dim=vocab_size,\n",
    "                              output_dim=query_maxlen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# embed the question into a sequence of vectors\n",
    "question_encoder = Sequential()\n",
    "question_encoder.add(Embedding(input_dim=vocab_size,\n",
    "                               output_dim=64,\n",
    "                               input_length=query_maxlen))\n",
    "question_encoder.add(Dropout(0.3))\n",
    "# output: (samples, query_maxlen, embedding_dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# encode input sequence and questions (which are indices)\n",
    "# to sequences of dense vectors\n",
    "input_encoded_m = input_encoder_m(input_sequence)\n",
    "input_encoded_c = input_encoder_c(input_sequence)\n",
    "question_encoded = question_encoder(question)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute a 'match' between the first input vector sequence\n",
    "# and the question vector sequence\n",
    "# shape: `(samples, story_maxlen, query_maxlen)`\n",
    "match = dot([input_encoded_m, question_encoded], axes=(2, 2))\n",
    "match = Activation('softmax')(match)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add the match matrix with the second input vector sequence\n",
    "response = add([match, input_encoded_c])  # (samples, story_maxlen, query_maxlen)\n",
    "response = Permute((2, 1))(response)  # (samples, query_maxlen, story_maxlen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# concatenate the match matrix with the question vector sequence\n",
    "answer = concatenate([response, question_encoded])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the original paper uses a matrix multiplication for this reduction step.\n",
    "# we choose to use a RNN instead.\n",
    "answer = LSTM(32)(answer)  # (samples, 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# one regularization layer -- more would probably be needed.\n",
    "answer = Dropout(0.3)(answer)\n",
    "answer = Dense(vocab_size)(answer)  # (samples, vocab_size)\n",
    "# we output a probability distribution over the vocabulary\n",
    "answer = Activation('softmax')(answer)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# build the final model\n",
    "model = Model([input_sequence, question], answer)\n",
    "model.compile(optimizer='rmsprop', loss='categorical_crossentropy',\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x18835fd0>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# train\n",
    "model.fit([inputs_train, queries_train], answers_train,\n",
    "              batch_size=32,\n",
    "              epochs=120,\n",
    "              callbacks=[plot],\n",
    "              validation_data=([inputs_test, queries_test], answers_test)\n",
    "         )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model save as pickle file\n",
    "model_path = r'./model_single_supporting_fact.h5'\n",
    "model.save(model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model load again\n",
    "# write story answer question in the format in a text file\n",
    "\n",
    "model.load_weights(model_path)\n",
    "pred_results = model.predict(([inputs_test, queries_test]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's test this with question\n",
    "idx = 345"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Vectorize the user input before input to the model\n",
    "inputs_test, queries_test, answers_test = vectorize_stories(\n",
    "    [(\n",
    "        test_stories[idx][0],\n",
    "        test_stories[idx][1],\n",
    "        test_stories[idx][2])\n",
    "    ],\n",
    "    word_idx, 68, 4\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Predict the answer using vectorized input\n",
    "predictions = model.predict(([inputs_test, queries_test]))\n",
    "\n",
    "# Convert predictions into 1-D array and make it a series\n",
    "# to use argmax() to get index of item with max value\n",
    "output = pd.Series(np.array(predictions.tolist()[0]))\n",
    "max = output.argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Story: Daniel went back to the hallway . Mary went back to the office .\r\n",
      "\n",
      "Question: Where is Mary ?\r\n",
      "\n",
      "Original Ans: office\r\n",
      "\n",
      "Predicted Ans: office\r\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Let's look at a single example\n",
    "\n",
    "print('Story: {}\\r\\n'.format(' '.join(word for word in test_stories[idx][0])))\n",
    "print('Question: {}\\r\\n'.format(' '.join(word for word in test_stories[idx][1])))\n",
    "print('Original Ans: {}\\r\\n'.format(test_stories[idx][2]))\n",
    "print('Predicted Ans: {}\\r\\n'.format(vocab_dict[max]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We can see in the above cell it has predicted the location correctly for Mary"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:tia]",
   "language": "python",
   "name": "conda-env-tia-py"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}