bAbI_qa_model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "glove_zip_file = \"glove.6B.zip\"\n",
    "glove_vectors_file = \"glove.6B.50d.txt\"\n",
    "\n",
    "# 15 MB\n",
    "data_set_zip = \"tasks_1-20_v1-2.tar.gz\"\n",
    "\n",
    "#Select \"task 5\"\n",
    "train_set_file = \"qa5_three-arg-relations_train.txt\"\n",
    "test_set_file = \"qa5_three-arg-relations_test.txt\"\n",
    "\n",
    "train_set_post_file = \"tasks_1-20_v1-2/en/\"+train_set_file\n",
    "test_set_post_file = \"tasks_1-20_v1-2/en/\"+test_set_file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Made using https://www.oreilly.com/ideas/question-answering-with-tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "import urllib\n",
    "import sys\n",
    "import os\n",
    "import zipfile\n",
    "import tarfile\n",
    "import json \n",
    "import hashlib\n",
    "import re\n",
    "import itertools\n",
    "import operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "try: from urllib.request import urlretrieve, urlopen\n",
    "except ImportError: \n",
    "    from urllib import urlretrieve\n",
    "    from urllib2 import urlopen\n",
    "#large file - 862 MB\n",
    "if (not os.path.isfile(glove_zip_file) and\n",
    "    not os.path.isfile(glove_vectors_file)):\n",
    "    urlretrieve (\"http://nlp.stanford.edu/data/glove.6B.zip\", \n",
    "                 glove_zip_file)\n",
    "if (not os.path.isfile(data_set_zip) and\n",
    "    not (os.path.isfile(train_set_file) and os.path.isfile(test_set_file))):\n",
    "    urlretrieve (\"https://s3.amazonaws.com/text-datasets/babi_tasks_1-20_v1-2.tar.gz\", \n",
    "                 data_set_zip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def unzip_single_file(zip_file_name, output_file_name):\n",
    "    \"\"\"\n",
    "        If the output file is already created, don't recreate\n",
    "        If the output file does not exist, create it from the zipFile\n",
    "    \"\"\"\n",
    "    if not os.path.isfile(output_file_name):\n",
    "        with open(output_file_name, 'wb') as out_file:\n",
    "            with zipfile.ZipFile(zip_file_name) as zipped:\n",
    "                for info in zipped.infolist():\n",
    "                    if output_file_name in info.filename:\n",
    "                        with zipped.open(info) as requested_file:\n",
    "                            out_file.write(requested_file.read())\n",
    "                            return\n",
    "def targz_unzip_single_file(zip_file_name, output_file_name, interior_relative_path):\n",
    "    if not os.path.isfile(output_file_name):\n",
    "        with tarfile.open(zip_file_name) as un_zipped:\n",
    "            un_zipped.extract(interior_relative_path+output_file_name)    \n",
    "unzip_single_file(glove_zip_file, glove_vectors_file)\n",
    "targz_unzip_single_file(data_set_zip, train_set_file, \"tasks_1-20_v1-2/en/\")\n",
    "targz_unzip_single_file(data_set_zip, test_set_file, \"tasks_1-20_v1-2/en/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Deserialize GloVe vectors\n",
    "glove_wordmap = {}\n",
    "with open(glove_vectors_file, \"r\") as glove:\n",
    "    for line in glove:\n",
    "        name, vector = tuple(line.split(\" \", 1))\n",
    "        glove_wordmap[name] = np.fromstring(vector, sep=\" \")\n",
    "wvecs = []\n",
    "for item in glove_wordmap.items():\n",
    "    wvecs.append(item[1])\n",
    "s = np.vstack(wvecs)\n",
    "\n",
    "# Gather the distribution hyperparameters\n",
    "v = np.var(s,0) \n",
    "m = np.mean(s,0) \n",
    "RS = np.random.RandomState()\n",
    "\n",
    "def fill_unk(unk):\n",
    "    global glove_wordmap\n",
    "    glove_wordmap[unk] = RS.multivariate_normal(m,np.diag(v))\n",
    "    return glove_wordmap[unk]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sentence2sequence(sentence):\n",
    "    \"\"\"\n",
    "\n",
    "    - Turns an input paragraph into an (n,d) matrix, \n",
    "        where n is the number of tokens in the sentence\n",
    "        and d is the number of dimensions each word vector has.\n",
    "\n",
    "      TensorFlow doesn't need to be used here, as simply\n",
    "      turning the sentence into a sequence based off our \n",
    "      mapping does not need the computational power that\n",
    "      TensorFlow provides. Normal Python suffices for this task.\n",
    "    \"\"\"\n",
    "    tokens = sentence.strip('\"(),-').lower().split(\" \")\n",
    "    rows = []\n",
    "    words = []\n",
    "    #Greedy search for tokens\n",
    "    for token in tokens:\n",
    "#         print token\n",
    "        i = len(token)\n",
    "        while len(token) > 0:\n",
    "            word = token[:i]\n",
    "            if word in glove_wordmap:\n",
    "                rows.append(glove_wordmap[word])\n",
    "                words.append(word)\n",
    "                token = token[i:]\n",
    "                i = len(token)\n",
    "                continue\n",
    "            else:\n",
    "                i = i-1\n",
    "#                 print token\n",
    "            if i == 0:\n",
    "                # word OOV\n",
    "                # https://arxiv.org/pdf/1611.01436.pdf\n",
    "                rows.append(fill_unk(token))\n",
    "                words.append(token)\n",
    "                break\n",
    "    return np.array(rows), words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(sentence2sequence(\"Hello sir how are you? My name is Sopan.\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contextualize(set_file):\n",
    "    \"\"\"\n",
    "    Read in the dataset of questions and build question+answer -> context sets.\n",
    "    Output is a list of data points, each of which is a 7-element tuple containing:\n",
    "        The sentences in the context in vectorized form.\n",
    "        The sentences in the context as a list of string tokens.\n",
    "        The question in vectorized form.\n",
    "        The question as a list of string tokens.\n",
    "        The answer in vectorized form.\n",
    "        The answer as a list of string tokens.\n",
    "        A list of numbers for supporting statements, which is currently unused.\n",
    "    \"\"\"\n",
    "    data = []\n",
    "    context = []\n",
    "    with open(set_file, \"r\") as train:\n",
    "        for line in train:\n",
    "            l, ine = tuple(line.split(\" \", 1))\n",
    "            # Split the line numbers from the sentences they refer to.\n",
    "            if l is \"1\":\n",
    "                # New contexts always start with 1, \n",
    "                # so this is a signal to reset the context.\n",
    "                context = []\n",
    "            if \"\\t\" in ine: \n",
    "                # Tabs are the separator between questions and answers,\n",
    "                # and are not present in context statements.\n",
    "                question, answer, support = tuple(ine.split(\"\\t\"))\n",
    "                data.append((tuple(zip(*context))+\n",
    "                             sentence2sequence(question)+\n",
    "                             sentence2sequence(answer)+\n",
    "                             ([int(s) for s in support.split()],)))\n",
    "                # Multiple questions may refer to the same context, so we don't reset it.\n",
    "            else:\n",
    "                # Context sentence.\n",
    "                context.append(sentence2sequence(ine[:-1]))\n",
    "    return data\n",
    "train_data = contextualize(train_set_post_file)\n",
    "test_data = contextualize(test_set_post_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_train_data = []\n",
    "def accumulate(iterable, func=operator.add):\n",
    "    'Return running totals'\n",
    "    # accumulate([1,2,3,4,5]) --> 1 3 6 10 15\n",
    "    # accumulate([1,2,3,4,5], operator.mul) --> 1 2 6 24 120\n",
    "    it = iter(iterable)\n",
    "    try:\n",
    "        total = next(it)\n",
    "    except StopIteration:\n",
    "        return\n",
    "    yield total\n",
    "    for element in it:\n",
    "        total = func(total, element)\n",
    "        yield total\n",
    "def finalize(data):\n",
    "    \"\"\"\n",
    "    Prepares data generated by contextualize() for use in the network.\n",
    "    \"\"\"\n",
    "    final_data = []\n",
    "    for cqas in train_data:\n",
    "        contextvs, contextws, qvs, qws, avs, aws, spt = cqas\n",
    "#         print cqas[0][0].shape\n",
    "\n",
    "        lengths = accumulate(len(cvec) for cvec in contextvs)\n",
    "        context_vec = np.concatenate(contextvs)\n",
    "        context_words = sum(contextws,[])\n",
    "\n",
    "        # Location markers for the beginnings of new sentences.\n",
    "        sentence_ends = np.array(list(lengths)) \n",
    "        final_data.append((context_vec, sentence_ends, qvs, spt, context_words, cqas, avs, aws))\n",
    "    return np.array(final_data)\n",
    "final_train_data = finalize(train_data)   \n",
    "final_test_data = finalize(test_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tf.reset_default_graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Hyperparameters\n",
    "\n",
    "# The number of dimensions used to store data passed between recurrent layers in the network.\n",
    "recurrent_cell_size = 128\n",
    "\n",
    "# The number of dimensions in our word vectorizations.\n",
    "D = 50 \n",
    "\n",
    "# How quickly the network learns. Too high, and we may run into numeric instability \n",
    "# or other issues.\n",
    "learning_rate = 0.005\n",
    "\n",
    "# Dropout probabilities. For a description of dropout and what these probabilities are, \n",
    "# see Entailment with TensorFlow.\n",
    "input_p, output_p = 0.5, 0.5\n",
    "\n",
    "# How many questions we train on at a time.\n",
    "batch_size = 128\n",
    "\n",
    "# Number of passes in episodic memory. We'll get to this later.\n",
    "passes = 4\n",
    "\n",
    "# Feed Forward layer sizes: the number of dimensions used to store data passed from feed-forward layers.\n",
    "ff_hidden_size = 256\n",
    "\n",
    "weight_decay = 0.00000001\n",
    "# The strength of our regularization. Increase to encourage sparsity in episodic memory, \n",
    "# but makes training slower. Don't make this larger than leraning_rate.\n",
    "\n",
    "training_iterations_count = 400000\n",
    "# How many questions the network trains on each time it is trained. \n",
    "# Some questions are counted multiple times.\n",
    "\n",
    "display_step = 100\n",
    "# How many iterations of training occur before each validation check."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Input Module\n",
    "\n",
    "# Context: A [batch_size, maximum_context_length, word_vectorization_dimensions] tensor \n",
    "# that contains all the context information.\n",
    "context = tf.placeholder(tf.float32, [None, None, D], \"context\")  \n",
    "context_placeholder = context # I use context as a variable name later on\n",
    "\n",
    "# input_sentence_endings: A [batch_size, maximum_sentence_count, 2] tensor that \n",
    "# contains the locations of the ends of sentences. \n",
    "input_sentence_endings = tf.placeholder(tf.int32, [None, None, 2], \"sentence\")\n",
    "\n",
    "# recurrent_cell_size: the number of hidden units in recurrent layers.\n",
    "input_gru = tf.contrib.rnn.GRUCell(recurrent_cell_size)\n",
    "\n",
    "# input_p: The probability of maintaining a specific hidden input unit.\n",
    "# Likewise, output_p is the probability of maintaining a specific hidden output unit.\n",
    "gru_drop = tf.contrib.rnn.DropoutWrapper(input_gru, input_p, output_p)\n",
    "\n",
    "# dynamic_rnn also returns the final internal state. We don't need that, and can\n",
    "# ignore the corresponding output (_). \n",
    "input_module_outputs, _ = tf.nn.dynamic_rnn(gru_drop, context, dtype=tf.float32, scope = \"input_module\")\n",
    "\n",
    "# cs: the facts gathered from the context.\n",
    "cs = tf.gather_nd(input_module_outputs, input_sentence_endings)\n",
    "# to use every word as a fact, useful for tasks with one-sentence contexts\n",
    "s = input_module_outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Question Module\n",
    "\n",
    "# query: A [batch_size, maximum_question_length, word_vectorization_dimensions] tensor \n",
    "#  that contains all of the questions.\n",
    "\n",
    "query = tf.placeholder(tf.float32, [None, None, D], \"query\")\n",
    "\n",
    "# input_query_lengths: A [batch_size, 2] tensor that contains question length information. \n",
    "# input_query_lengths[:,1] has the actual lengths; input_query_lengths[:,0] is a simple range() \n",
    "# so that it plays nice with gather_nd.\n",
    "input_query_lengths = tf.placeholder(tf.int32, [None, 2], \"query_lengths\")\n",
    "\n",
    "question_module_outputs, _ = tf.nn.dynamic_rnn(gru_drop, query, dtype=tf.float32, \n",
    "                                               scope = tf.VariableScope(True, \"input_module\"))\n",
    "\n",
    "# q: the question states. A [batch_size, recurrent_cell_size] tensor.\n",
    "q = tf.gather_nd(question_module_outputs, input_query_lengths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Episodic Memory\n",
    "\n",
    "# make sure the current memory (i.e. the question vector) is broadcasted along the facts dimension\n",
    "size = tf.stack([tf.constant(1),tf.shape(cs)[1], tf.constant(1)])\n",
    "re_q = tf.tile(tf.reshape(q,[-1,1,recurrent_cell_size]),size)\n",
    "\n",
    "\n",
    "# Final output for attention, needs to be 1 in order to create a mask\n",
    "output_size = 1 \n",
    "\n",
    "# Weights and biases\n",
    "attend_init = tf.random_normal_initializer(stddev=0.1)\n",
    "w_1 = tf.get_variable(\"attend_w1\", [1,recurrent_cell_size*7, recurrent_cell_size], \n",
    "                      tf.float32, initializer = attend_init)\n",
    "w_2 = tf.get_variable(\"attend_w2\", [1,recurrent_cell_size, output_size], \n",
    "                      tf.float32, initializer = attend_init)\n",
    "\n",
    "b_1 = tf.get_variable(\"attend_b1\", [1, recurrent_cell_size], \n",
    "                      tf.float32, initializer = attend_init)\n",
    "b_2 = tf.get_variable(\"attend_b2\", [1, output_size], \n",
    "                      tf.float32, initializer = attend_init)\n",
    "\n",
    "# Regulate all the weights and biases\n",
    "tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, tf.nn.l2_loss(w_1))\n",
    "tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, tf.nn.l2_loss(b_1))\n",
    "tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, tf.nn.l2_loss(w_2))\n",
    "tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, tf.nn.l2_loss(b_2))\n",
    "\n",
    "def attention(c, mem, existing_facts):\n",
    "    \"\"\"\n",
    "    Custom attention mechanism.\n",
    "    c: A [batch_size, maximum_sentence_count, recurrent_cell_size] tensor \n",
    "        that contains all the facts from the contexts.\n",
    "    mem: A [batch_size, maximum_sentence_count, recurrent_cell_size] tensor that \n",
    "        contains the current memory. It should be the same memory for all facts for accurate results.\n",
    "    existing_facts: A [batch_size, maximum_sentence_count, 1] tensor that \n",
    "        acts as a binary mask for which facts exist and which do not.\n",
    "\n",
    "    \"\"\"\n",
    "    with tf.variable_scope(\"attending\") as scope:\n",
    "        # attending: The metrics by which we decide what to attend to.\n",
    "        attending = tf.concat([c, mem, re_q, c * re_q,  c * mem, (c-re_q)**2, (c-mem)**2], 2)\n",
    "\n",
    "        # m1: First layer of multiplied weights for the feed-forward network. \n",
    "        #     We tile the weights in order to manually broadcast, since tf.matmul does not\n",
    "        #     automatically broadcast batch matrix multiplication as of TensorFlow 1.2.\n",
    "        m1 = tf.matmul(attending * existing_facts, \n",
    "                       tf.tile(w_1, tf.stack([tf.shape(attending)[0],1,1]))) * existing_facts\n",
    "        # bias_1: A masked version of the first feed-forward layer's bias\n",
    "        #     over only existing facts.\n",
    "\n",
    "        bias_1 = b_1 * existing_facts\n",
    "\n",
    "        # tnhan: First nonlinearity. In the original paper, this is a tanh nonlinearity; \n",
    "        #        choosing relu was a design choice intended to avoid issues with \n",
    "        #        low gradient magnitude when the tanh returned values close to 1 or -1. \n",
    "        tnhan = tf.nn.relu(m1 + bias_1)\n",
    "\n",
    "        # m2: Second layer of multiplied weights for the feed-forward network. \n",
    "        #     Still tiling weights for the same reason described in m1's comments.\n",
    "        m2 = tf.matmul(tnhan, tf.tile(w_2, tf.stack([tf.shape(attending)[0],1,1])))\n",
    "\n",
    "        # bias_2: A masked version of the second feed-forward layer's bias.\n",
    "        bias_2 = b_2 * existing_facts\n",
    "\n",
    "        # norm_m2: A normalized version of the second layer of weights, which is used \n",
    "        #     to help make sure the softmax nonlinearity doesn't saturate.\n",
    "        norm_m2 = tf.nn.l2_normalize(m2 + bias_2, -1)\n",
    "\n",
    "        # softmaxable: A hack in order to use sparse_softmax on an otherwise dense tensor. \n",
    "        #     We make norm_m2 a sparse tensor, then make it dense again after the operation.\n",
    "        softmax_idx = tf.where(tf.not_equal(norm_m2, 0))[:,:-1]\n",
    "        softmax_gather = tf.gather_nd(norm_m2[...,0], softmax_idx)\n",
    "        softmax_shape = tf.shape(norm_m2, out_type=tf.int64)[:-1]\n",
    "        softmaxable = tf.SparseTensor(softmax_idx, softmax_gather, softmax_shape)\n",
    "        return tf.expand_dims(tf.sparse_tensor_to_dense(tf.sparse_softmax(softmaxable)),-1)\n",
    "\n",
    "# facts_0s: a [batch_size, max_facts_length, 1] tensor \n",
    "#     whose values are 1 if the corresponding fact exists and 0 if not.\n",
    "facts_0s = tf.cast(tf.count_nonzero(input_sentence_endings[:,:,-1:],-1,keep_dims=True),tf.float32)\n",
    "\n",
    "\n",
    "with tf.variable_scope(\"Episodes\") as scope:\n",
    "    attention_gru = tf.contrib.rnn.GRUCell(recurrent_cell_size)\n",
    "\n",
    "    # memory: A list of all tensors that are the (current or past) memory state \n",
    "    #   of the attention mechanism.\n",
    "    memory = [q]\n",
    "\n",
    "    # attends: A list of all tensors that represent what the network attends to.\n",
    "    attends = []\n",
    "    for a in range(passes):\n",
    "        # attention mask\n",
    "        attend_to = attention(cs, tf.tile(tf.reshape(memory[-1],[-1,1,recurrent_cell_size]),size),\n",
    "                              facts_0s)\n",
    "\n",
    "        # Inverse attention mask, for what's retained in the state.\n",
    "        retain = 1-attend_to\n",
    "\n",
    "        # GRU pass over the facts, according to the attention mask.\n",
    "        while_valid_index = (lambda state, index: index < tf.shape(cs)[1])\n",
    "        update_state = (lambda state, index: (attend_to[:,index,:] * \n",
    "                                                 attention_gru(cs[:,index,:], state)[0] + \n",
    "                                                 retain[:,index,:] * state))\n",
    "        # start loop with most recent memory and at the first index\n",
    "        memory.append(tuple(tf.while_loop(while_valid_index,\n",
    "                          (lambda state, index: (update_state(state,index),index+1)),\n",
    "                           loop_vars = [memory[-1], 0]))[0]) \n",
    "\n",
    "        attends.append(attend_to)\n",
    "\n",
    "        # Reuse variables so the GRU pass uses the same variables every pass.\n",
    "        scope.reuse_variables()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Answer Module\n",
    "\n",
    "# a0: Final memory state. (Input to answer module)\n",
    "a0 = tf.concat([memory[-1], q], -1)\n",
    "\n",
    "# fc_init: Initializer for the final fully connected layer's weights.\n",
    "fc_init = tf.random_normal_initializer(stddev=0.1) \n",
    "\n",
    "with tf.variable_scope(\"answer\"):\n",
    "    # w_answer: The final fully connected layer's weights.\n",
    "    w_answer = tf.get_variable(\"weight\", [recurrent_cell_size*2, D], \n",
    "                               tf.float32, initializer = fc_init)\n",
    "    # Regulate the fully connected layer's weights\n",
    "    tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, \n",
    "                     tf.nn.l2_loss(w_answer)) \n",
    "\n",
    "    # The regressed word. This isn't an actual word yet; \n",
    "    #    we still have to find the closest match.\n",
    "    logit = tf.expand_dims(tf.matmul(a0, w_answer),1)\n",
    "\n",
    "    # Make a mask over which words exist.\n",
    "    with tf.variable_scope(\"ending\"):\n",
    "        all_ends = tf.reshape(input_sentence_endings, [-1,2])\n",
    "        range_ends = tf.range(tf.shape(all_ends)[0])\n",
    "        ends_indices = tf.stack([all_ends[:,0],range_ends], axis=1)\n",
    "        ind = tf.reduce_max(tf.scatter_nd(ends_indices, all_ends[:,1],\n",
    "                                          [tf.shape(q)[0], tf.shape(all_ends)[0]]),\n",
    "                            axis=-1)\n",
    "        range_ind = tf.range(tf.shape(ind)[0])\n",
    "        mask_ends = tf.cast(tf.scatter_nd(tf.stack([ind, range_ind], axis=1), \n",
    "                                          tf.ones_like(range_ind), [tf.reduce_max(ind)+1, \n",
    "                                                                    tf.shape(ind)[0]]), bool)\n",
    "        # A bit of a trick. With the locations of the ends of the mask (the last periods in \n",
    "        #  each of the contexts) as 1 and the rest as 0, we can scan with exclusive or \n",
    "        #  (starting from all 1). For each context in the batch, this will result in 1s \n",
    "        #  up until the marker (the location of that last period) and 0s afterwards.\n",
    "        mask = tf.scan(tf.logical_xor,mask_ends, tf.ones_like(range_ind, dtype=bool))\n",
    "\n",
    "    # We score each possible word inversely with their Euclidean distance to the regressed word.\n",
    "    #  The highest score (lowest distance) will correspond to the selected word.\n",
    "    logits = -tf.reduce_sum(tf.square(context*tf.transpose(tf.expand_dims(\n",
    "                    tf.cast(mask, tf.float32),-1),[1,0,2]) - logit), axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Training\n",
    "\n",
    "# gold_standard: The real answers.\n",
    "gold_standard = tf.placeholder(tf.float32, [None, 1, D], \"answer\")\n",
    "with tf.variable_scope('accuracy'):\n",
    "    eq = tf.equal(context, gold_standard)\n",
    "    corrbool = tf.reduce_all(eq,-1)\n",
    "    logloc = tf.reduce_max(logits, -1, keep_dims = True)\n",
    "    # locs: A boolean tensor that indicates where the score \n",
    "    #  matches the minimum score. This happens on multiple dimensions, \n",
    "    #  so in the off chance there's one or two indexes that match \n",
    "    #  we make sure it matches in all indexes.\n",
    "    locs = tf.equal(logits, logloc)\n",
    "\n",
    "    # correctsbool: A boolean tensor that indicates for which \n",
    "    #   words in the context the score always matches the minimum score.\n",
    "    correctsbool = tf.reduce_any(tf.logical_and(locs, corrbool), -1)\n",
    "    # corrects: A tensor that is simply correctsbool cast to floats.\n",
    "    corrects = tf.where(correctsbool, tf.ones_like(correctsbool, dtype=tf.float32), \n",
    "                        tf.zeros_like(correctsbool,dtype=tf.float32))\n",
    "\n",
    "    # corr: corrects, but for the right answer instead of our selected answer.\n",
    "    corr = tf.where(corrbool, tf.ones_like(corrbool, dtype=tf.float32), \n",
    "                        tf.zeros_like(corrbool,dtype=tf.float32))\n",
    "with tf.variable_scope(\"loss\"):\n",
    "    # Use sigmoid cross entropy as the base loss, \n",
    "    #  with our distances as the relative probabilities. There are\n",
    "    #  multiple correct labels, for each location of the answer word within the context.\n",
    "    loss = tf.nn.sigmoid_cross_entropy_with_logits(logits = tf.nn.l2_normalize(logits,-1),\n",
    "                                                   labels = corr)\n",
    "\n",
    "    # Add regularization losses, weighted by weight_decay.\n",
    "    total_loss = tf.reduce_mean(loss) + weight_decay * tf.add_n(\n",
    "        tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n",
    "\n",
    "# TensorFlow's default implementation of the Adam optimizer works. We can adjust more than \n",
    "#  just the learning rate, but it's not necessary to find a very good optimum.\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate)\n",
    "\n",
    "# Once we have an optimizer, we ask it to minimize the loss \n",
    "#   in order to work towards the proper training.\n",
    "opt_op = optimizer.minimize(total_loss)\n",
    "# Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Initialize variables\n",
    "init = tf.global_variables_initializer()\n",
    "\n",
    "# Launch the TensorFlow session\n",
    "sess = tf.Session()\n",
    "sess.run(init)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def prep_batch(batch_data, more_data = False):\n",
    "    \"\"\"\n",
    "        Prepare all the preproccessing that needs to be done on a batch-by-batch basis.\n",
    "    \"\"\"\n",
    "    context_vec, sentence_ends, questionvs, spt, context_words, cqas, answervs, _ = zip(*batch_data)\n",
    "    ends = list(sentence_ends)\n",
    "    maxend = max(map(len, ends))\n",
    "    aends = np.zeros((len(ends), maxend))\n",
    "    for index, i in enumerate(ends):\n",
    "        for indexj, x in enumerate(i):\n",
    "            aends[index, indexj] = x-1\n",
    "    new_ends = np.zeros(aends.shape+(2,))\n",
    "\n",
    "    for index, x in np.ndenumerate(aends):\n",
    "        new_ends[index+(0,)] = index[0]\n",
    "        new_ends[index+(1,)] = x\n",
    "\n",
    "    contexts = list(context_vec)\n",
    "    max_context_length = max([len(x) for x in contexts])\n",
    "    contextsize = list(np.array(contexts[0]).shape)\n",
    "    contextsize[0] = max_context_length\n",
    "    final_contexts = np.zeros([len(contexts)]+contextsize)\n",
    "\n",
    "    contexts = [np.array(x) for x in contexts]\n",
    "    for i, context in enumerate(contexts):\n",
    "        final_contexts[i,0:len(context),:] = context\n",
    "    max_query_length = max(len(x) for x in questionvs)\n",
    "    querysize = list(np.array(questionvs[0]).shape)\n",
    "    querysize[:1] = [len(questionvs),max_query_length]\n",
    "    queries = np.zeros(querysize)\n",
    "    querylengths = np.array(list(zip(range(len(questionvs)),[len(q)-1 for q in questionvs])))\n",
    "    questions = [np.array(q) for q in questionvs]\n",
    "    for i, question in enumerate(questions):\n",
    "        queries[i,0:len(question),:] = question\n",
    "    data = {context_placeholder: final_contexts, input_sentence_endings: new_ends, \n",
    "                            query:queries, input_query_lengths:querylengths, gold_standard: answervs}\n",
    "    return (data, context_words, cqas) if more_data else data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 1/235 [00:17<1:07:23, 17.28s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Iter 0, Minibatch Loss= ', 0.67294413, 'Accuracy= ', 0.0046875002)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 43%|████▎     | 101/235 [04:24<05:50,  2.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Iter 100, Minibatch Loss= ', 0.67279965, 'Accuracy= ', 0.36953124)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 86%|████████▌ | 201/235 [08:22<01:24,  2.50s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Iter 200, Minibatch Loss= ', 0.67277646, 'Accuracy= ', 0.44687501)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 235/235 [09:42<00:00,  2.48s/it]\n"
     ]
    }
   ],
   "source": [
    "# Use TQDM if installed\n",
    "tqdm_installed = False\n",
    "try:\n",
    "    from tqdm import tqdm\n",
    "    tqdm_installed = True\n",
    "except:\n",
    "    pass\n",
    "\n",
    "\n",
    "# Prepare validation set\n",
    "batch = np.random.randint(final_test_data.shape[0], size=batch_size*10)\n",
    "batch_data = final_test_data[batch]\n",
    "\n",
    "validation_set, val_context_words, val_cqas = prep_batch(batch_data, True)\n",
    "\n",
    "# training_iterations_count: The number of data pieces to train on in total\n",
    "# batch_size: The number of data pieces per batch\n",
    "def train(iterations, batch_size):\n",
    "    training_iterations = range(0,iterations,batch_size)\n",
    "    if tqdm_installed:\n",
    "        # Add a progress bar if TQDM is installed\n",
    "        training_iterations = tqdm(training_iterations)\n",
    "\n",
    "    wordz = []\n",
    "    for j in training_iterations:\n",
    "\n",
    "        batch = np.random.randint(final_train_data.shape[0], size=batch_size)\n",
    "        batch_data = final_train_data[batch]\n",
    "\n",
    "        sess.run([opt_op], feed_dict=prep_batch(batch_data))\n",
    "        if (j/batch_size) % display_step == 0:\n",
    "\n",
    "            # Calculate batch accuracy\n",
    "            acc, ccs, tmp_loss, log, con, cor, loc  = sess.run([corrects, cs, total_loss, logit,\n",
    "                                                                context_placeholder,corr, locs], \n",
    "                                                               feed_dict=validation_set)\n",
    "            # Display results\n",
    "            print(\"Iter \" + str(j/batch_size) + \", Minibatch Loss= \",tmp_loss,\n",
    "                  \"Accuracy= \", np.mean(acc))\n",
    "train(30000,batch_size) # Small amount of training for preliminary results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEKCAYAAAARnO4WAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fad338cefd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEKCAYAAAARnO4WAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nL0mVMPAlqRIGviRVwsCXpEr8H3F636IHBfAVAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fad2a771e90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEKCAYAAAAVaT4rAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fad2a6b3310>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEKCAYAAAARnO4WAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\naoSFL0mN+H+VmYyTYv0fmQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fad1c1d6c50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEKCAYAAAARnO4WAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fad1c108fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ancr = sess.run([corrbool,locs, total_loss, logits, facts_0s, w_1]+attends+\n",
    "                [query, cs, question_module_outputs],feed_dict=validation_set)\n",
    "a = ancr[0]\n",
    "n = ancr[1]\n",
    "cr = ancr[2]\n",
    "attenders = np.array(ancr[6:-3]) \n",
    "faq = np.sum(ancr[4], axis=(-1,-2)) # Number of facts in each context\n",
    "\n",
    "limit = 5\n",
    "for question in range(min(limit, batch_size)):\n",
    "    plt.yticks(range(passes,0,-1))\n",
    "    plt.ylabel(\"Episode\")\n",
    "    plt.xlabel(\"Question \"+str(question+1))\n",
    "    pltdata = attenders[:,question,:int(faq[question]),0] \n",
    "    # Display only information about facts that actually exist, all others are 0\n",
    "    pltdata = (pltdata - pltdata.mean()) / ((pltdata.max() - pltdata.min() + 0.001)) * 256\n",
    "    plt.pcolor(pltdata, cmap=plt.cm.BuGn, alpha=0.7)\n",
    "    plt.show()\n",
    "\n",
    "#print(list(map((lambda x: x.shape),ancr[3:])), new_ends.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('TEXT: ', 'bill went to the hallway . mary journeyed to the hallway . fred went to the garden . mary moved to the office . jeff went to the garden . bill grabbed the football there . jeff went back to the bedroom . bill left the football . bill grabbed the football there . mary went to the bedroom . bill went back to the office . fred travelled to the bathroom . mary went to the office . bill dropped the football there . mary went to the hallway . mary travelled to the garden . bill travelled to the kitchen . mary went to the bedroom . mary moved to the garden . fred grabbed the milk there . mary travelled to the hallway . fred went back to the bedroom . fred gave the milk to jeff . jeff handed the milk to fred . fred passed the milk to jeff . jeff handed the milk to fred .')\n",
      "('QUESTION: ', 'who did jeff give the milk to ?')\n",
      "('RESPONSE: ', 'fred', 'Correct')\n",
      "('EXPECTED: ', 'fred')\n",
      "()\n",
      "('TEXT: ', 'bill travelled to the bathroom . bill moved to the hallway . bill journeyed to the office . bill travelled to the garden . bill grabbed the apple there . bill moved to the kitchen . mary moved to the office . mary journeyed to the bathroom . fred went back to the office . bill dropped the apple . jeff journeyed to the garden . mary went back to the garden . jeff moved to the hallway . bill got the apple there . bill travelled to the bathroom . mary grabbed the football there . bill dropped the apple . mary moved to the bedroom . mary left the football . jeff journeyed to the kitchen . jeff travelled to the bedroom . jeff went back to the kitchen . jeff moved to the bathroom . bill got the apple there . mary picked up the football there . bill gave the apple to jeff . jeff travelled to the bedroom . mary discarded the football . jeff passed the apple to mary . mary went to the garden . mary moved to the office . mary left the apple .')\n",
      "('QUESTION: ', 'what did jeff give to mary ?')\n",
      "('RESPONSE: ', 'football', 'Incorrect')\n",
      "('EXPECTED: ', 'apple')\n",
      "()\n",
      "('TEXT: ', 'jeff travelled to the garden . fred journeyed to the kitchen . fred travelled to the bedroom . jeff went to the bathroom . mary went back to the office . mary went to the bedroom . mary journeyed to the kitchen . fred travelled to the hallway . mary journeyed to the bedroom . fred grabbed the apple there . bill travelled to the garden . fred discarded the apple . mary went to the kitchen . bill picked up the football there . fred moved to the office . mary travelled to the hallway . mary got the apple there . bill left the football . bill got the football there . fred got the milk there . mary dropped the apple . bill went to the bedroom . bill went back to the garden . jeff moved to the bedroom . mary went back to the garden . bill gave the football to mary . mary dropped the football . bill travelled to the bedroom . mary took the football there . bill travelled to the garden .')\n",
      "('QUESTION: ', 'who gave the football ?')\n",
      "('RESPONSE: ', 'mary', 'Incorrect')\n",
      "('EXPECTED: ', 'bill')\n",
      "()\n",
      "('TEXT: ', 'mary went back to the garden . fred picked up the apple there . mary went back to the bedroom . bill grabbed the milk there . bill discarded the milk . bill grabbed the milk there . fred moved to the office . fred gave the apple to jeff .')\n",
      "('QUESTION: ', 'who gave the apple ?')\n",
      "('RESPONSE: ', 'fred', 'Correct')\n",
      "('EXPECTED: ', 'fred')\n",
      "()\n",
      "('TEXT: ', 'jeff journeyed to the kitchen . mary journeyed to the garden . bill went back to the office . bill took the milk there . jeff went back to the bathroom . mary moved to the bathroom . jeff moved to the office . bill moved to the bedroom . fred moved to the kitchen . bill journeyed to the bathroom . jeff journeyed to the bathroom . mary journeyed to the kitchen . bill put down the milk . jeff got the milk there . jeff gave the milk to bill . jeff went to the hallway . mary went back to the bedroom . jeff moved to the office . fred travelled to the bathroom . bill gave the milk to fred . jeff moved to the hallway . fred passed the milk to bill .')\n",
      "('QUESTION: ', 'who did fred give the milk to ?')\n",
      "('RESPONSE: ', 'fred', 'Incorrect')\n",
      "('EXPECTED: ', 'bill')\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "# Locations of responses within contexts\n",
    "indices = np.argmax(n,axis=1)\n",
    "\n",
    "# Locations of actual answers within contexts \n",
    "indicesc = np.argmax(a,axis=1)\n",
    "\n",
    "for i,e,cw, cqa in list(zip(indices, indicesc, val_context_words, val_cqas))[:limit]:\n",
    "    ccc = \" \".join(cw)\n",
    "    print(\"TEXT: \",ccc)\n",
    "    print (\"QUESTION: \", \" \".join(cqa[3]))\n",
    "    print (\"RESPONSE: \", cw[i], [\"Correct\", \"Incorrect\"][i!=e])\n",
    "    print(\"EXPECTED: \", cw[e])\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Implementations",
   "language": "python",
   "name": "impl_env"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}