t81_558_class11_text_nlp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# T81-558: Applications of Deep Neural Networks\n",
    "**Class 11: Natural Language Processing and Speech Recognition**\n",
    "* Instructor: [Jeff Heaton](https://sites.wustl.edu/jeffheaton/), School of Engineering and Applied Science, [Washington University in St. Louis](https://engineering.wustl.edu/Programs/Pages/default.aspx)\n",
    "* For more information visit the [class website](https://sites.wustl.edu/jeffheaton/t81-558/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module Videos\n",
    "\n",
    "Watch the following videos for this class session:\n",
    "\n",
    "* [Module 11, Live Update](https://www.youtube.com/watch?v=Dtg01Iyq4Ls)\n",
    "* [Module 11, Part 1: Chatbots and NLP](https://www.youtube.com/watch?v=bv_iVVrlfbU)\n",
    "* [Module 11, Part 2: End to End Networks](https://www.youtube.com/watch?v=qN9hHlZKIL4)\n",
    "* [Module 11, Part 3: Word2Vec](https://www.youtube.com/watch?v=Ae3GVw5nTYU)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helpful Functions\n",
    "\n",
    "These are exactly the same feature vector encoding functions from [Class 3](https://github.com/jeffheaton/t81_558_deep_learning/blob/master/t81_558_class3_training.ipynb).  They must be defined for this class as well.  For more information, refer to class 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import preprocessing\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import shutil\n",
    "import os\n",
    "\n",
    "\n",
    "# Encode text values to dummy variables(i.e. [1,0,0],[0,1,0],[0,0,1] for red,green,blue)\n",
    "def encode_text_dummy(df, name):\n",
    "    dummies = pd.get_dummies(df[name])\n",
    "    for x in dummies.columns:\n",
    "        dummy_name = \"{}-{}\".format(name, x)\n",
    "        df[dummy_name] = dummies[x]\n",
    "    df.drop(name, axis=1, inplace=True)\n",
    "\n",
    "\n",
    "# Encode text values to a single dummy variable.  The new columns (which do not replace the old) will have a 1\n",
    "# at every location where the original column (name) matches each of the target_values.  One column is added for\n",
    "# each target value.\n",
    "def encode_text_single_dummy(df, name, target_values):\n",
    "    for tv in target_values:\n",
    "        l = list(df[name].astype(str))\n",
    "        l = [1 if str(x) == str(tv) else 0 for x in l]\n",
    "        name2 = \"{}-{}\".format(name, tv)\n",
    "        df[name2] = l\n",
    "\n",
    "\n",
    "# Encode text values to indexes(i.e. [1],[2],[3] for red,green,blue).\n",
    "def encode_text_index(df, name):\n",
    "    le = preprocessing.LabelEncoder()\n",
    "    df[name] = le.fit_transform(df[name])\n",
    "    return le.classes_\n",
    "\n",
    "\n",
    "# Encode a numeric column as zscores\n",
    "def encode_numeric_zscore(df, name, mean=None, sd=None):\n",
    "    if mean is None:\n",
    "        mean = df[name].mean()\n",
    "\n",
    "    if sd is None:\n",
    "        sd = df[name].std()\n",
    "\n",
    "    df[name] = (df[name] - mean) / sd\n",
    "\n",
    "\n",
    "# Convert all missing values in the specified column to the median\n",
    "def missing_median(df, name):\n",
    "    med = df[name].median()\n",
    "    df[name] = df[name].fillna(med)\n",
    "\n",
    "\n",
    "# Convert all missing values in the specified column to the default\n",
    "def missing_default(df, name, default_value):\n",
    "    df[name] = df[name].fillna(default_value)\n",
    "\n",
    "\n",
    "# Convert a Pandas dataframe to the x,y inputs that TensorFlow needs\n",
    "def to_xy(df, target):\n",
    "    result = []\n",
    "    for x in df.columns:\n",
    "        if x != target:\n",
    "            result.append(x)\n",
    "    # find out the type of the target column.  Is it really this hard? :(\n",
    "    target_type = df[target].dtypes\n",
    "    target_type = target_type[0] if hasattr(target_type, '__iter__') else target_type\n",
    "    # Encode to int for classification, float otherwise. TensorFlow likes 32 bits.\n",
    "    if target_type in (np.int64, np.int32):\n",
    "        # Classification\n",
    "        dummies = pd.get_dummies(df[target])\n",
    "        return df.as_matrix(result).astype(np.float32), dummies.as_matrix().astype(np.float32)\n",
    "    else:\n",
    "        # Regression\n",
    "        return df.as_matrix(result).astype(np.float32), df.as_matrix([target]).astype(np.float32)\n",
    "\n",
    "# Nicely formatted time string\n",
    "def hms_string(sec_elapsed):\n",
    "    h = int(sec_elapsed / (60 * 60))\n",
    "    m = int((sec_elapsed % (60 * 60)) / 60)\n",
    "    s = sec_elapsed % 60\n",
    "    return \"{}:{:>02}:{:>05.2f}\".format(h, m, s)\n",
    "\n",
    "\n",
    "# Regression chart.\n",
    "def chart_regression(pred,y,sort=True):\n",
    "    t = pd.DataFrame({'pred' : pred, 'y' : y.flatten()})\n",
    "    if sort:\n",
    "        t.sort_values(by=['y'],inplace=True)\n",
    "    a = plt.plot(t['y'].tolist(),label='expected')\n",
    "    b = plt.plot(t['pred'].tolist(),label='prediction')\n",
    "    plt.ylabel('output')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "# Remove all rows where the specified column is +/- sd standard deviations\n",
    "def remove_outliers(df, name, sd):\n",
    "    drop_rows = df.index[(np.abs(df[name] - df[name].mean()) >= (sd * df[name].std()))]\n",
    "    df.drop(drop_rows, axis=0, inplace=True)\n",
    "\n",
    "\n",
    "# Encode a column to a range between normalized_low and normalized_high.\n",
    "def encode_numeric_range(df, name, normalized_low=-1, normalized_high=1,\n",
    "                         data_low=None, data_high=None):\n",
    "    if data_low is None:\n",
    "        data_low = min(df[name])\n",
    "        data_high = max(df[name])\n",
    "\n",
    "    df[name] = ((df[name] - data_low) / (data_high - data_low)) \\\n",
    "               * (normalized_high - normalized_low) + normalized_low"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chat Bots\n",
    "\n",
    "Using the above code you can create your own primitive chat bots.  A some what famous video on Youtube from Cornell University shows what happens [when two chat bots converse](https://www.youtube.com/watch?v=WnzlbyTZsQY).  Other interesting chat bot type technology:\n",
    "\n",
    "* [CleverBot](http://www.cleverbot.com/)\n",
    "* [Computer Science Paper Generator](https://pdos.csail.mit.edu/archive/scigen/)\n",
    "\n",
    "### Other Resources\n",
    "* [Word Net](http://wordnet.princeton.edu/)\n",
    "* [bAbI Datasets](https://research.fb.com/downloads/babi/)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# End-To-End Memory Networks\n",
    "\n",
    "The origional source papers for End-to-End Memory Networks:\n",
    "\n",
    "* Jason Weston, Antoine Bordes, Sumit Chopra, Tomas Mikolov, Alexander M. Rush, [\"Towards AI-Complete Question Answering: A Set of Prerequisite Toy Tasks\"](http://arxiv.org/abs/1502.05698)\n",
    "* Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, Rob Fergus, [\"End-To-End Memory Networks\"](http://arxiv.org/abs/1503.08895)\n",
    "\n",
    "Other useful links for End-To-End Memory Networks\n",
    "\n",
    "* [bAbI Datasets](https://research.fb.com/downloads/babi/)\n",
    "* [Keras End-To-End Memory Networks](https://github.com/fchollet/keras/blob/master/examples/babi_memnn.py)\n",
    "* [Online JavaScript Demo of End-to-End Memory Networks](http://yerevann.com/dmn-ui/#/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Imports and Utility Functions\n",
    "\n",
    "The following imports are needed to create the end-to-end memory network. Neither Keras nor TensorFlow directly support End-to-End Memory Networks (yet), so it is necessary to create them using existing tools.  Several functions are needed defined here to read the bAbI dataset that we are using to train."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential, Model\n",
    "from keras.layers.embeddings import Embedding\n",
    "from keras.layers import Input, Activation, Dense, Permute, Dropout, 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 keras.models import load_model\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn import metrics\n",
    "from functools import reduce\n",
    "import pickle\n",
    "import tarfile\n",
    "import numpy as np\n",
    "import re\n",
    "import os\n",
    "import time\n",
    "\n",
    "\n",
    "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()]\n",
    "\n",
    "\n",
    "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\n",
    "\n",
    "\n",
    "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\n",
    "\n",
    "\n",
    "def vectorize_stories(data):\n",
    "    inputs, queries, answers = [], [], []\n",
    "    for story, query, answer in data:\n",
    "        inputs.append([word_idx[w] for w in story])\n",
    "        queries.append([word_idx[w] for w in query])\n",
    "        answers.append(word_idx[answer])\n",
    "    return (pad_sequences(inputs, maxlen=story_maxlen),\n",
    "            pad_sequences(queries, maxlen=query_maxlen),\n",
    "            np.array(answers))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Getting the Data\n",
    "\n",
    "The data is downloaded from the Internet, if needed.\n",
    "\n",
    "As you can see (below), this dataset contains stories and questions about those stories.  The computer is not learning these specific stories below, but rather how to read a story and answer a question about that story.  Consider the first story \"Mary moved to the bathroom. John went to the hallway.\" the computer is not learning that Mary is in the bathroom or John is in the hallway, this changes per story.  Rather, the computer is learning to parse the story and extract information about individual people and their locations.\n",
    "\n",
    "The computer is learning to read, at least in a limited sense."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting stories for the challenge: single_supporting_fact_10k\n"
     ]
    }
   ],
   "source": [
    "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\n",
    "tar = tarfile.open(path)\n",
    "\n",
    "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",
    "}\n",
    "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')))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Story: Mary moved to the bathroom . John went to the hallway .\n",
      "Query: Where is Mary ?\n",
      "Answer: bathroom\n",
      "---\n",
      "Story: Mary moved to the bathroom . John went to the hallway . Daniel went back to the hallway . Sandra moved to the garden .\n",
      "Query: Where is Daniel ?\n",
      "Answer: hallway\n",
      "---\n",
      "Story: Mary moved to the bathroom . John went to the hallway . Daniel went back to the hallway . Sandra moved to the garden . John moved to the office . Sandra journeyed to the bathroom .\n",
      "Query: Where is Daniel ?\n",
      "Answer: hallway\n",
      "---\n",
      "Story: Mary moved to the bathroom . John went to the hallway . Daniel went back to the hallway . Sandra moved to the garden . John moved to the office . Sandra journeyed to the bathroom . Mary moved to the hallway . Daniel travelled to the office .\n",
      "Query: Where is Daniel ?\n",
      "Answer: office\n",
      "---\n",
      "Story: Mary moved to the bathroom . John went to the hallway . Daniel went back to the hallway . Sandra moved to the garden . John moved to the office . Sandra journeyed to the bathroom . Mary moved to the hallway . Daniel travelled to the office . John went back to the garden . John moved to the bedroom .\n",
      "Query: Where is Sandra ?\n",
      "Answer: bathroom\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "# See what the data looks like\n",
    "\n",
    "for i in range(5):\n",
    "    print(\"Story: {}\".format(' '.join(train_stories[i][0])))\n",
    "    print(\"Query: {}\".format(' '.join(train_stories[i][1])))\n",
    "    print(\"Answer: {}\".format(train_stories[i][2]))\n",
    "    print(\"---\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Building the Vocabulary\n",
    "\n",
    "This type of neural network can only deal with a set vocabulary.  The words are indexed and each becomes a number.  Words not in the training vocabulary will not be recognized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-\n",
      "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', '.'], ['Where', 'is', 'Mary', '?'], 'bathroom')\n",
      "-\n",
      "(0, '.')\n",
      "(1, '?')\n",
      "(2, 'Daniel')\n",
      "(3, 'John')\n",
      "(4, 'Mary')\n",
      "(5, 'Sandra')\n",
      "(6, 'Where')\n",
      "(7, 'back')\n",
      "(8, 'bathroom')\n",
      "(9, 'bedroom')\n",
      "(10, 'garden')\n",
      "(11, 'hallway')\n",
      "(12, 'is')\n",
      "(13, 'journeyed')\n",
      "(14, 'kitchen')\n",
      "(15, 'moved')\n",
      "(16, 'office')\n",
      "(17, 'the')\n",
      "(18, 'to')\n",
      "(19, 'travelled')\n",
      "(20, 'went')\n"
     ]
    }
   ],
   "source": [
    "vocab = set()\n",
    "for story, q, answer in train_stories + test_stories:\n",
    "    vocab |= set(story + q + [answer])\n",
    "vocab = sorted(vocab)\n",
    "\n",
    "# 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)))\n",
    "\n",
    "print('-')\n",
    "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[0])\n",
    "print('-')\n",
    "\n",
    "\n",
    "for s in list(enumerate(vocab)):\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Building the Training and Test Data\n",
    "\n",
    "The training data that is actually sent to the neural network is the vectorized representation of the sentences.  Each word is replaced by its vocab number.  Additionally there are two parts to the input (x) data: story and query.  The answer (x) is a always a single vocab word number.  This is a classification network.  Any of the vocab words could potentially be the answer.  Stories can be at most 68 words and questions at most 4.  Both of these limits are automatically determined from the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vectorizing the word sequences...\n",
      "-\n",
      "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,)\n",
      "answers_test shape: (1000,)\n",
      "-\n"
     ]
    }
   ],
   "source": [
    "print('Vectorizing the word sequences...')\n",
    "word_idx = dict((c, i + 1) for i, c in enumerate(vocab))\n",
    "inputs_train, queries_train, answers_train = vectorize_stories(train_stories)\n",
    "inputs_test, queries_test, answers_test = vectorize_stories(test_stories)\n",
    "\n",
    "print('-')\n",
    "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Story (x): [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  5 16 19 18  9  1  4 21 19 18 12  1]\n",
      "Question (x): [ 7 13  5  2]\n",
      "Answer: 9\n"
     ]
    }
   ],
   "source": [
    "# See individual training element.\n",
    "\n",
    "print(\"Story (x): {}\".format(inputs_train[0]))\n",
    "print(\"Question (x): {}\".format(queries_train[0]))\n",
    "print(\"Answer: {}\".format(answers_train[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compile the Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling...\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "print('Compiling...')\n",
    "\n",
    "# placeholders\n",
    "input_sequence = Input((story_maxlen,))\n",
    "question = Input((query_maxlen,))\n",
    "\n",
    "# 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)\n",
    "\n",
    "# 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))\n",
    "input_encoder_c.add(Dropout(0.3))\n",
    "# output: (samples, story_maxlen, query_maxlen)\n",
    "\n",
    "# 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)\n",
    "\n",
    "# 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)\n",
    "\n",
    "# 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)\n",
    "\n",
    "# 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)\n",
    "\n",
    "# concatenate the match matrix with the question vector sequence\n",
    "answer = concatenate([response, question_encoded])\n",
    "\n",
    "# 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)\n",
    "\n",
    "# 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",
    "\n",
    "# build the final model\n",
    "model = Model([input_sequence, question], answer)\n",
    "model.compile(optimizer='rmsprop', loss='sparse_categorical_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "print(\"Done.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train the Neural Network\n",
    "\n",
    "It will take some time (probably up to 1/2 hour) to train this network on a CPU.  The network is saved.  If you've previously saved the neural network, you can skip this step and load the neural network in the next step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 10000 samples, validate on 1000 samples\n",
      "Epoch 1/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.9430 - acc: 0.1690 - val_loss: 1.7966 - val_acc: 0.2000\n",
      "Epoch 2/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.7146 - acc: 0.2598 - val_loss: 1.6037 - val_acc: 0.3830\n",
      "Epoch 3/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.5756 - acc: 0.3625 - val_loss: 1.5044 - val_acc: 0.4090\n",
      "Epoch 4/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.5223 - acc: 0.3850 - val_loss: 1.4769 - val_acc: 0.4170\n",
      "Epoch 5/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.5057 - acc: 0.3965 - val_loss: 1.4632 - val_acc: 0.4290\n",
      "Epoch 6/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.4882 - acc: 0.4013 - val_loss: 1.4504 - val_acc: 0.4650\n",
      "Epoch 7/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.4619 - acc: 0.4303 - val_loss: 1.4778 - val_acc: 0.4160\n",
      "Epoch 8/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.4252 - acc: 0.4578 - val_loss: 1.3827 - val_acc: 0.4780\n",
      "Epoch 9/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.3858 - acc: 0.4740 - val_loss: 1.3371 - val_acc: 0.5270\n",
      "Epoch 10/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.3638 - acc: 0.4811 - val_loss: 1.3079 - val_acc: 0.5240\n",
      "Epoch 11/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.3437 - acc: 0.4840 - val_loss: 1.2885 - val_acc: 0.5180\n",
      "Epoch 12/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.3252 - acc: 0.5009 - val_loss: 1.3106 - val_acc: 0.5210\n",
      "Epoch 13/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.3114 - acc: 0.5034 - val_loss: 1.2632 - val_acc: 0.5260\n",
      "Epoch 14/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.3039 - acc: 0.5007 - val_loss: 1.2566 - val_acc: 0.5240\n",
      "Epoch 15/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2842 - acc: 0.5097 - val_loss: 1.2496 - val_acc: 0.5310\n",
      "Epoch 16/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2769 - acc: 0.5138 - val_loss: 1.2446 - val_acc: 0.5270\n",
      "Epoch 17/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2655 - acc: 0.5164 - val_loss: 1.2408 - val_acc: 0.5240\n",
      "Epoch 18/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2715 - acc: 0.5072 - val_loss: 1.2385 - val_acc: 0.5250\n",
      "Epoch 19/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2533 - acc: 0.5133 - val_loss: 1.2409 - val_acc: 0.5240\n",
      "Epoch 20/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2539 - acc: 0.5182 - val_loss: 1.2251 - val_acc: 0.5240\n",
      "Epoch 21/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2480 - acc: 0.5249 - val_loss: 1.2254 - val_acc: 0.5200\n",
      "Epoch 22/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2399 - acc: 0.5137 - val_loss: 1.2208 - val_acc: 0.5200\n",
      "Epoch 23/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2267 - acc: 0.5167 - val_loss: 1.2234 - val_acc: 0.5160\n",
      "Epoch 24/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2191 - acc: 0.5213 - val_loss: 1.2133 - val_acc: 0.5230\n",
      "Epoch 25/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2207 - acc: 0.5256 - val_loss: 1.2122 - val_acc: 0.5280\n",
      "Epoch 26/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2143 - acc: 0.5243 - val_loss: 1.2053 - val_acc: 0.5310\n",
      "Epoch 27/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.2067 - acc: 0.5239 - val_loss: 1.1960 - val_acc: 0.5260\n",
      "Epoch 28/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.1999 - acc: 0.5276 - val_loss: 1.2031 - val_acc: 0.5200\n",
      "Epoch 29/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.1894 - acc: 0.5299 - val_loss: 1.2036 - val_acc: 0.5140\n",
      "Epoch 30/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.1845 - acc: 0.5253 - val_loss: 1.1870 - val_acc: 0.5160\n",
      "Epoch 31/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.1756 - acc: 0.5308 - val_loss: 1.1775 - val_acc: 0.5220\n",
      "Epoch 32/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.1655 - acc: 0.5382 - val_loss: 1.1742 - val_acc: 0.5170\n",
      "Epoch 33/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.1569 - acc: 0.5356 - val_loss: 1.1577 - val_acc: 0.5250\n",
      "Epoch 34/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.1445 - acc: 0.5302 - val_loss: 1.1637 - val_acc: 0.5280\n",
      "Epoch 35/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.1349 - acc: 0.5429 - val_loss: 1.1698 - val_acc: 0.5330\n",
      "Epoch 36/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.1153 - acc: 0.5542 - val_loss: 1.1146 - val_acc: 0.5480\n",
      "Epoch 37/120\n",
      "10000/10000 [==============================] - 2s - loss: 1.0490 - acc: 0.5930 - val_loss: 0.9731 - val_acc: 0.6460\n",
      "Epoch 38/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.8572 - acc: 0.6979 - val_loss: 0.7663 - val_acc: 0.7260\n",
      "Epoch 39/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.7378 - acc: 0.7457 - val_loss: 0.7040 - val_acc: 0.7420\n",
      "Epoch 40/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.6757 - acc: 0.7690 - val_loss: 0.6602 - val_acc: 0.7500\n",
      "Epoch 41/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.6399 - acc: 0.7698 - val_loss: 0.6475 - val_acc: 0.7550\n",
      "Epoch 42/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.6078 - acc: 0.7814 - val_loss: 0.6027 - val_acc: 0.7730\n",
      "Epoch 43/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.5746 - acc: 0.7890 - val_loss: 0.5624 - val_acc: 0.7870\n",
      "Epoch 44/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.5333 - acc: 0.8049 - val_loss: 0.5285 - val_acc: 0.8030\n",
      "Epoch 45/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.4945 - acc: 0.8196 - val_loss: 0.4800 - val_acc: 0.8140\n",
      "Epoch 46/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.4587 - acc: 0.8306 - val_loss: 0.4377 - val_acc: 0.8340\n",
      "Epoch 47/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.4272 - acc: 0.8408 - val_loss: 0.4339 - val_acc: 0.8420\n",
      "Epoch 48/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.4070 - acc: 0.8531 - val_loss: 0.4095 - val_acc: 0.8440\n",
      "Epoch 49/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.3974 - acc: 0.8567 - val_loss: 0.3832 - val_acc: 0.8580\n",
      "Epoch 50/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.3784 - acc: 0.8594 - val_loss: 0.3932 - val_acc: 0.8470\n",
      "Epoch 51/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.3516 - acc: 0.8729 - val_loss: 0.3908 - val_acc: 0.8500\n",
      "Epoch 52/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.3462 - acc: 0.8712 - val_loss: 0.3797 - val_acc: 0.8510\n",
      "Epoch 53/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.3365 - acc: 0.8764 - val_loss: 0.3590 - val_acc: 0.8590\n",
      "Epoch 54/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.3327 - acc: 0.8759 - val_loss: 0.3277 - val_acc: 0.8680\n",
      "Epoch 55/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.3124 - acc: 0.8801 - val_loss: 0.3204 - val_acc: 0.8720\n",
      "Epoch 56/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.3068 - acc: 0.8875 - val_loss: 0.3155 - val_acc: 0.8720\n",
      "Epoch 57/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2993 - acc: 0.8877 - val_loss: 0.3054 - val_acc: 0.8770\n",
      "Epoch 58/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2912 - acc: 0.8880 - val_loss: 0.2949 - val_acc: 0.8800\n",
      "Epoch 59/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2861 - acc: 0.8900 - val_loss: 0.3009 - val_acc: 0.8810\n",
      "Epoch 60/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2775 - acc: 0.8977 - val_loss: 0.3087 - val_acc: 0.8820\n",
      "Epoch 61/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2644 - acc: 0.9017 - val_loss: 0.2911 - val_acc: 0.8890\n",
      "Epoch 62/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2607 - acc: 0.9057 - val_loss: 0.2778 - val_acc: 0.8870\n",
      "Epoch 63/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2468 - acc: 0.9107 - val_loss: 0.2561 - val_acc: 0.9010\n",
      "Epoch 64/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2374 - acc: 0.9127 - val_loss: 0.2678 - val_acc: 0.8950\n",
      "Epoch 65/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2310 - acc: 0.9161 - val_loss: 0.2406 - val_acc: 0.9070\n",
      "Epoch 66/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2241 - acc: 0.9172 - val_loss: 0.2901 - val_acc: 0.8900\n",
      "Epoch 67/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2103 - acc: 0.9253 - val_loss: 0.2416 - val_acc: 0.9090\n",
      "Epoch 68/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.2090 - acc: 0.9231 - val_loss: 0.2119 - val_acc: 0.9230\n",
      "Epoch 69/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1969 - acc: 0.9293 - val_loss: 0.2080 - val_acc: 0.9280\n",
      "Epoch 70/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1940 - acc: 0.9317 - val_loss: 0.2004 - val_acc: 0.9270\n",
      "Epoch 71/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1947 - acc: 0.9329 - val_loss: 0.2050 - val_acc: 0.9270\n",
      "Epoch 72/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1902 - acc: 0.9363 - val_loss: 0.2152 - val_acc: 0.9240\n",
      "Epoch 73/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1876 - acc: 0.9334 - val_loss: 0.1837 - val_acc: 0.9310\n",
      "Epoch 74/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1762 - acc: 0.9375 - val_loss: 0.1885 - val_acc: 0.9350\n",
      "Epoch 75/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1724 - acc: 0.9397 - val_loss: 0.1742 - val_acc: 0.9400\n",
      "Epoch 76/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1629 - acc: 0.9421 - val_loss: 0.2050 - val_acc: 0.9310\n",
      "Epoch 77/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1641 - acc: 0.9414 - val_loss: 0.1838 - val_acc: 0.9360\n",
      "Epoch 78/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1603 - acc: 0.9433 - val_loss: 0.1933 - val_acc: 0.9370\n",
      "Epoch 79/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1502 - acc: 0.9493 - val_loss: 0.1800 - val_acc: 0.9360\n",
      "Epoch 80/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1482 - acc: 0.9489 - val_loss: 0.1753 - val_acc: 0.9430\n",
      "Epoch 81/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1446 - acc: 0.9496 - val_loss: 0.1971 - val_acc: 0.9330\n",
      "Epoch 82/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1467 - acc: 0.9489 - val_loss: 0.1545 - val_acc: 0.9470\n",
      "Epoch 83/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1395 - acc: 0.9510 - val_loss: 0.1673 - val_acc: 0.9440\n",
      "Epoch 84/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1418 - acc: 0.9508 - val_loss: 0.2159 - val_acc: 0.9340\n",
      "Epoch 85/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1430 - acc: 0.9506 - val_loss: 0.1806 - val_acc: 0.9380\n",
      "Epoch 86/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1313 - acc: 0.9526 - val_loss: 0.1879 - val_acc: 0.9350\n",
      "Epoch 87/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1265 - acc: 0.9555 - val_loss: 0.1587 - val_acc: 0.9430\n",
      "Epoch 88/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1271 - acc: 0.9563 - val_loss: 0.1694 - val_acc: 0.9370\n",
      "Epoch 89/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1255 - acc: 0.9562 - val_loss: 0.1700 - val_acc: 0.9330\n",
      "Epoch 90/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1194 - acc: 0.9590 - val_loss: 0.1560 - val_acc: 0.9470\n",
      "Epoch 91/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1204 - acc: 0.9571 - val_loss: 0.1615 - val_acc: 0.9390\n",
      "Epoch 92/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1182 - acc: 0.9598 - val_loss: 0.1482 - val_acc: 0.9530\n",
      "Epoch 93/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1167 - acc: 0.9575 - val_loss: 0.1580 - val_acc: 0.9450\n",
      "Epoch 94/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1170 - acc: 0.9599 - val_loss: 0.1453 - val_acc: 0.9450\n",
      "Epoch 95/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1121 - acc: 0.9604 - val_loss: 0.1966 - val_acc: 0.9340\n",
      "Epoch 96/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1171 - acc: 0.9611 - val_loss: 0.1529 - val_acc: 0.9460\n",
      "Epoch 97/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1100 - acc: 0.9622 - val_loss: 0.1342 - val_acc: 0.9510\n",
      "Epoch 98/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1092 - acc: 0.9602 - val_loss: 0.1619 - val_acc: 0.9470\n",
      "Epoch 99/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1059 - acc: 0.9628 - val_loss: 0.1477 - val_acc: 0.9460\n",
      "Epoch 100/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1068 - acc: 0.9657 - val_loss: 0.1511 - val_acc: 0.9500\n",
      "Epoch 101/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1003 - acc: 0.9655 - val_loss: 0.1735 - val_acc: 0.9440\n",
      "Epoch 102/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1007 - acc: 0.9648 - val_loss: 0.1476 - val_acc: 0.9500\n",
      "Epoch 103/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0943 - acc: 0.9676 - val_loss: 0.1414 - val_acc: 0.9480\n",
      "Epoch 104/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0942 - acc: 0.9681 - val_loss: 0.1531 - val_acc: 0.9510\n",
      "Epoch 105/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1013 - acc: 0.9660 - val_loss: 0.1396 - val_acc: 0.9490\n",
      "Epoch 106/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.1016 - acc: 0.9646 - val_loss: 0.1349 - val_acc: 0.9530\n",
      "Epoch 107/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0899 - acc: 0.9693 - val_loss: 0.1478 - val_acc: 0.9510\n",
      "Epoch 108/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0906 - acc: 0.9676 - val_loss: 0.1546 - val_acc: 0.9490\n",
      "Epoch 109/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0889 - acc: 0.9706 - val_loss: 0.1448 - val_acc: 0.9490\n",
      "Epoch 110/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0871 - acc: 0.9691 - val_loss: 0.1392 - val_acc: 0.9560\n",
      "Epoch 111/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0872 - acc: 0.9720 - val_loss: 0.1399 - val_acc: 0.9540\n",
      "Epoch 112/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0823 - acc: 0.9715 - val_loss: 0.1366 - val_acc: 0.9530\n",
      "Epoch 113/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0878 - acc: 0.9709 - val_loss: 0.1558 - val_acc: 0.9500\n",
      "Epoch 114/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0809 - acc: 0.9740 - val_loss: 0.1372 - val_acc: 0.9540\n",
      "Epoch 115/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0876 - acc: 0.9726 - val_loss: 0.1303 - val_acc: 0.9550\n",
      "Epoch 116/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0766 - acc: 0.9720 - val_loss: 0.1592 - val_acc: 0.9470\n",
      "Epoch 117/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0793 - acc: 0.9721 - val_loss: 0.1613 - val_acc: 0.9500\n",
      "Epoch 118/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0790 - acc: 0.9732 - val_loss: 0.1330 - val_acc: 0.9550\n",
      "Epoch 119/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0759 - acc: 0.9730 - val_loss: 0.1312 - val_acc: 0.9570\n",
      "Epoch 120/120\n",
      "10000/10000 [==============================] - 2s - loss: 0.0784 - acc: 0.9730 - val_loss: 0.1648 - val_acc: 0.9510\n",
      "Elapsed time: 0:04:20.16\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "# train\n",
    "model.fit([inputs_train, queries_train], answers_train,\n",
    "          batch_size=32,\n",
    "          epochs=120,\n",
    "          validation_data=([inputs_test, queries_test], answers_test))\n",
    "\n",
    "# save\n",
    "save_path = \"./dnn/\"\n",
    "# save entire network to HDF5 (save everything, suggested)\n",
    "model.save(os.path.join(save_path,\"chatbot.h5\"))\n",
    "# save the vocab too, indexes must be the same\n",
    "pickle.dump( vocab, open( os.path.join(save_path,\"vocab.pkl\"), \"wb\" ) )\n",
    "\n",
    "elapsed_time = time.time() - start_time\n",
    "print(\"Elapsed time: {}\".format(hms_string(elapsed_time)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the model, if it exists, load vocab too\n",
    "save_path = \"./dnn/\"\n",
    "model = load_model(os.path.join(save_path,\"chatbot.h5\"))\n",
    "vocab = pickle.load( open( os.path.join(save_path,\"vocab.pkl\"), \"rb\" ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Evaluate Accuracy\n",
    "\n",
    "We evaluate the accuracy, using the same technique as previous classification networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  2.05029846e-18   2.74736253e-18   2.77777589e-18 ...,   2.82850275e-18\n",
      "    2.79275696e-18   3.02297498e-18]\n",
      " [  3.98315486e-19   4.71528621e-19   4.80154202e-19 ...,   4.36820278e-19\n",
      "    6.42037170e-19   5.05143639e-19]\n",
      " [  3.25365557e-21   3.79500933e-21   5.19666971e-21 ...,   4.41672038e-21\n",
      "    4.41025520e-21   3.36303849e-21]\n",
      " ..., \n",
      " [  2.89851273e-19   3.54907038e-19   3.16197156e-19 ...,   3.42959163e-19\n",
      "    4.03119260e-19   3.42802180e-19]\n",
      " [  1.09258267e-17   1.44349998e-17   1.54180577e-17 ...,   1.48079557e-17\n",
      "    1.73701361e-17   1.63851608e-17]\n",
      " [  2.52862158e-11   2.81528065e-11   2.65718003e-11 ...,   2.73308043e-11\n",
      "    2.52099834e-11   2.56702125e-11]]\n"
     ]
    }
   ],
   "source": [
    "pred = model.predict([inputs_test, queries_test])\n",
    "# See what the predictions look like, they are just probabilities of each class.\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12  9 15 12 15 12 11 12 17 17 15 11 17 10 10 15 11 15 17 12 12 17 17 12 10\n",
      " 10 10 15 15 11 12 17 15 15  9 17  9 11 15 10  9 11 11 12 11 15 12  9 17 10\n",
      " 10 17 11 11 11 10 15 12 11 12 12 17  9 11 11 15 15  9 17  9 11 12 11 10  9\n",
      " 15 15 15 12 17 11  9 10 15 17 11 11 12 15 15  9  9 12  9 17 15 15 15 10 10\n",
      " 10  9 17 11 11 12 10  9 17 10  9  9 15 12 15 11 17 15  9 17 10  9  9 12 10\n",
      " 17 11 11 11  9 11 17  9 11 11  9 17 15  9  9 17 12 12 17 10 15 15 15 15 15\n",
      " 11 11  9 17 10  9 11 10 17 12 10 10 10 11  9 11 11 11 15 10 17 17 11  9  9\n",
      " 17 15 10 17 17 12  9 12 12 10  9 17 11 15 17 12 15 11 12 12 11 17 15  9 10\n",
      " 12 17 12 10 12  9 15 12  9  9  9 10 12 10 12 10  9 12 12  9  9 12 15 12 10\n",
      " 17 12 11  9  9 17 11 12 17 11 10 10  9 10 10 12 15 11 11 15 15 11 11 17 11\n",
      " 10 17  9  9 10 10 17 17 15 11 11 17 12 17 17  9 11 10  9 10 15 17 17 15  9\n",
      " 17 15 12 17  9  9 11 17 17 11 17  9 17 11  9 15 15 10 15 15 11 11 12 12  9\n",
      "  9  9 15 17 12 11  9 17 17 15 11 11 17 10 11 17 10 17 10 11 11 15 15 11 11\n",
      "  9 10 11 11 10 15 17 15 10 11 17 12 11 12 15 12 11 17 15 11 17 12 12 11 15\n",
      " 10 11 11 10 10  9 17 12 11 12 11  9 11 11 11 11 11 12 12 12 12 12 11 11 17\n",
      " 10 15  9 15 10  9 10 10 17 17 15 17 17 17 15 15 12  9 10 17 17 10 17  9 11\n",
      " 10 11 10 15 17 15 12 12 11 15 10 11  9 12 17 10 10 15 12  9 12 12  9 12 10\n",
      " 15 15 17 10 10 17 15 15 15 17 11 11  9 10 11 10 12  9 11 10 11 10 12 11 15\n",
      " 15 15 15 11  9 15 10 12 11 12  9 11 10 17 11 11 10 10 10 17 12 17 17  9 15\n",
      " 11  9 15 11  9 10 10 12 12 11 10  9 12 10  9 15 10 10 11 11 15 15 10 12 12\n",
      " 15 11  9 12  9 15 10 17  9 10 10 17 10 10 17  9  9 10 12 11 17 17 12 12 11\n",
      " 12 17 11 11 12 11 11 11 17  9 11 10 12 12 10 11 17 12 12 15 11 15 15 12 10\n",
      " 10  9 17 10 15 12 15 10 10 11 11 10 11 15 10  9  9 15 10 12 10 10 11 15 17\n",
      "  9 10 12 10 10 12 12 11 15 10 10 11 12 10 10 17 12 17 11  9  9 17 17 11 10\n",
      " 10 10 15 15 17 11 15 12 11 10 15 17  9 11  9 17 15 12 15 17 11 17 17 15  9\n",
      " 10  9 10 10 10  9 10 10 15 11 11 11 15 12  9 11 11 10 17 11 11 12 17 15 11\n",
      "  9 11 15 15 11  9 15 15 11 15 15 15 11 10 10  9 17 17 17  9 10 10 17  9 15\n",
      "  9 17 12 12  9 15 15 15 17  9 11  9 11  9 12 11  9  9 17 11 11 11 11 15 10\n",
      " 12 12  9  9 17 12 12  9 17 12 11 11 15 15 12 11 12 17 12 17 11 12 11 17 17\n",
      " 11 11  9 11  9 10 10 12 17 10 12  9  9  9 15 11 11 15 17  9 10  9 12 17 15\n",
      " 17 17 12 10 15 11 11 17 15  9 17 10  9 11 12 15  9 15 12 10  9 10 17 17 15\n",
      " 15  9  9 15 17 10 17 17  9 12 17 17 12 12 11 11 11 15 17 11 17 17 17 17 17\n",
      " 12  9 17 10 17 11 10 10 12 12 11 11 17 12 12 17 17 15 11 17 11 11  9 12 15\n",
      " 17  9 10  9 15 11  9 15 15 10  9  9  9 17 17 11 11 17 15 15 10 10 11 11  9\n",
      " 10 12  9 10 10 10 10 10 15 17  9 11 17 15 12 11 10 10 15 12 10 11 12 12 11\n",
      " 11 11 15 12 17 10 12 17 15 12 10 10 12 17 10 11 17 11 12 17 17 11 12 11 17\n",
      "  9  9 11 11 11 11 15 15 11 17 10 10 17 12 11 15 12 11 11 10  9 12 12 15 10\n",
      "  9 17 15 17  9 17 17 10 17 15 12 12 11 10 10 10 17 17 15 12 17  9  9 15 10\n",
      " 12 15 15 15 17 17 15 11 15 10 12  9  9 10 11 11  9  9 12 15  9 15  9 12 12\n",
      " 10 17 17 10 12 15  9 10 17 11 11 11 17  9  9 11 15 11 11 11 15 12 17  9 11]\n"
     ]
    }
   ],
   "source": [
    "# Use argmax to turn those into actual predictions.  The class (word) with the highest\n",
    "# probability is the answer.\n",
    "\n",
    "pred = np.argmax(pred,axis=1)\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final accuracy: 0.951\n"
     ]
    }
   ],
   "source": [
    "score = metrics.accuracy_score(answers_test, pred)\n",
    "print(\"Final accuracy: {}\".format(score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adhoc Query\n",
    "\n",
    "You might want to create your own stories and questions.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Remember, I only know these words: ['.', '?', 'Daniel', 'John', 'Mary', 'Sandra', 'Where', 'back', 'bathroom', 'bedroom', 'garden', 'hallway', 'is', 'journeyed', 'kitchen', 'moved', 'office', 'the', 'to', 'travelled', 'went']\n",
      "\n",
      "[  4.50810289e-15   5.88824906e-15   5.82686797e-15   5.69384356e-15\n",
      "   5.04950984e-15   5.34106154e-15   6.27564000e-15   5.40989864e-15\n",
      "   5.44526226e-15   9.44914483e-03   1.44550813e-05   9.05848861e-01\n",
      "   4.09616659e-05   6.00117803e-15   6.55487373e-15   8.12432989e-02\n",
      "   6.20458537e-15   3.40330810e-03   6.63244374e-15   5.28002435e-15\n",
      "   6.80855756e-15   5.02990018e-15]\n",
      "Answer: garden([11])\n"
     ]
    }
   ],
   "source": [
    "print(\"Remember, I only know these words: {}\".format(vocab))\n",
    "print()\n",
    "story = \"Daniel went to the hallway. Mary went to the bathroom.  Daniel went to the bedroom.\"\n",
    "query = \"Where is Sandra?\"\n",
    "\n",
    "adhoc_stories = (tokenize(story), tokenize(query), '?')\n",
    "\n",
    "adhoc_train, adhoc_query, adhoc_answer = vectorize_stories([adhoc_stories])\n",
    "\n",
    "pred = model.predict([adhoc_train, adhoc_query])\n",
    "print(pred[0])\n",
    "pred = np.argmax(pred,axis=1)\n",
    "print(\"Answer: {}({})\".format(vocab[pred[0]-1],pred))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Word2Vec\n",
    "\n",
    "Word2vec is a group of related models that are used to produce word embeddings. These models are shallow, two-layer neural networks that are trained to reconstruct linguistic contexts of words. Word2vec takes as its input a large corpus of text and produces a vector space, typically of several hundred dimensions, with each unique word in the corpus being assigned a corresponding vector in the space. Word vectors are positioned in the vector space such that words that share common contexts in the corpus are located in close proximity to one another in the space.\n",
    "\n",
    "Mikolov, T., Chen, K., Corrado, G., & Dean, J. (2013). [Efficient estimation of word representations in vector space](https://arxiv.org/abs/1301.3781). arXiv preprint arXiv:1301.3781.\n",
    "\n",
    "![Word2Vec](https://pbs.twimg.com/media/C7jJxIjWkAA8E_s.jpg)\n",
    "[Trust Word2Vec](https://twitter.com/DanilBaibak/status/844647217885581312)\n",
    "\n",
    "### Suggested Software for Word2Vec\n",
    "\n",
    "* [GoogleNews Vectors](https://code.google.com/archive/p/word2vec/), [GitHub Mirror](https://github.com/mmihaltz/word2vec-GoogleNews-vectors)\n",
    "* [Python Gensim](https://radimrehurek.com/gensim/)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/jtheaton/.keras/datasets/GoogleNews-vectors-negative300.bin.gz\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    path = get_file('GoogleNews-vectors-negative300.bin.gz', origin='https://s3.amazonaws.com/dl4j-distribution/GoogleNews-vectors-negative300.bin.gz')\n",
    "except:\n",
    "    print('Error downloading')\n",
    "    raise\n",
    "    \n",
    "print(path)    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Slow version of gensim.models.doc2vec is being used\n"
     ]
    }
   ],
   "source": [
    "import gensim\n",
    "\n",
    "# Not that the path below refers to a location on my hard drive.\n",
    "# You should download GoogleNews Vectors (see suggested software above)\n",
    "model = gensim.models.KeyedVectors.load_word2vec_format(path, binary=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Word2vec makes each word a vector.  We are using the 300-number vector, which can be seen for the word \"hello\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = model['hello']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300\n"
     ]
    }
   ],
   "source": [
    "print(len(w))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.05419922  0.01708984 -0.00527954  0.33203125 -0.25       -0.01397705\n",
      " -0.15039062 -0.265625    0.01647949  0.3828125  -0.03295898 -0.09716797\n",
      " -0.16308594 -0.04443359  0.00946045  0.18457031  0.03637695  0.16601562\n",
      "  0.36328125 -0.25585938  0.375       0.171875    0.21386719 -0.19921875\n",
      "  0.13085938 -0.07275391 -0.02819824  0.11621094  0.15332031  0.09082031\n",
      "  0.06787109 -0.0300293  -0.16894531 -0.20800781 -0.03710938 -0.22753906\n",
      "  0.26367188  0.012146    0.18359375  0.31054688 -0.10791016 -0.19140625\n",
      "  0.21582031  0.13183594 -0.03515625  0.18554688 -0.30859375  0.04785156\n",
      " -0.10986328  0.14355469 -0.43554688 -0.0378418   0.10839844  0.140625\n",
      " -0.10595703  0.26171875 -0.17089844  0.39453125  0.12597656 -0.27734375\n",
      " -0.28125     0.14746094 -0.20996094  0.02355957  0.18457031  0.00445557\n",
      " -0.27929688 -0.03637695 -0.29296875  0.19628906  0.20703125  0.2890625\n",
      " -0.20507812  0.06787109 -0.43164062 -0.10986328 -0.2578125  -0.02331543\n",
      "  0.11328125  0.23144531 -0.04418945  0.10839844 -0.2890625  -0.09521484\n",
      " -0.10351562 -0.0324707   0.07763672 -0.13378906  0.22949219  0.06298828\n",
      "  0.08349609  0.02929688 -0.11474609  0.00534058 -0.12988281  0.02514648\n",
      "  0.08789062  0.24511719 -0.11474609 -0.296875   -0.59375    -0.29492188\n",
      " -0.13378906  0.27734375 -0.04174805  0.11621094  0.28320312  0.00241089\n",
      "  0.13867188 -0.00683594 -0.30078125  0.16210938  0.01171875 -0.13867188\n",
      "  0.48828125  0.02880859  0.02416992  0.04736328  0.05859375 -0.23828125\n",
      "  0.02758789  0.05981445 -0.03857422  0.06933594  0.14941406 -0.10888672\n",
      " -0.07324219  0.08789062  0.27148438  0.06591797 -0.37890625 -0.26171875\n",
      " -0.13183594  0.09570312 -0.3125      0.10205078  0.03063965  0.23632812\n",
      "  0.00582886  0.27734375  0.20507812 -0.17871094 -0.31445312 -0.01586914\n",
      "  0.13964844  0.13574219  0.0390625  -0.29296875  0.234375   -0.33984375\n",
      " -0.11816406  0.10644531 -0.18457031 -0.02099609  0.02563477  0.25390625\n",
      "  0.07275391  0.13574219 -0.00138092 -0.2578125  -0.2890625   0.10107422\n",
      "  0.19238281 -0.04882812  0.27929688 -0.3359375  -0.07373047  0.01879883\n",
      " -0.10986328 -0.04614258  0.15722656  0.06689453 -0.03417969  0.16308594\n",
      "  0.08642578  0.44726562  0.02026367 -0.01977539  0.07958984  0.17773438\n",
      " -0.04370117 -0.00952148  0.16503906  0.17285156  0.23144531 -0.04272461\n",
      "  0.02355957  0.18359375 -0.41601562 -0.01745605  0.16796875  0.04736328\n",
      "  0.14257812  0.08496094  0.33984375  0.1484375  -0.34375    -0.14160156\n",
      " -0.06835938 -0.14648438 -0.02844238  0.07421875 -0.07666016  0.12695312\n",
      "  0.05859375 -0.07568359 -0.03344727  0.23632812 -0.16308594  0.16503906\n",
      "  0.1484375  -0.2421875  -0.3515625  -0.30664062  0.00491333  0.17675781\n",
      "  0.46289062  0.14257812 -0.25       -0.25976562  0.04370117  0.34960938\n",
      "  0.05957031  0.07617188 -0.02868652 -0.09667969 -0.01281738  0.05859375\n",
      " -0.22949219 -0.1953125  -0.12207031  0.20117188 -0.42382812  0.06005859\n",
      "  0.50390625  0.20898438  0.11230469 -0.06054688  0.33203125  0.07421875\n",
      " -0.05786133  0.11083984 -0.06494141  0.05639648  0.01757812  0.08398438\n",
      "  0.13769531  0.2578125   0.16796875 -0.16894531  0.01794434  0.16015625\n",
      "  0.26171875  0.31640625 -0.24804688  0.05371094 -0.0859375   0.17089844\n",
      " -0.39453125 -0.00156403 -0.07324219 -0.04614258 -0.16210938 -0.15722656\n",
      "  0.21289062 -0.15820312  0.04394531  0.28515625  0.01196289 -0.26953125\n",
      " -0.04370117  0.37109375  0.04663086 -0.19726562  0.3046875  -0.36523438\n",
      " -0.23632812  0.08056641 -0.04248047 -0.14648438 -0.06225586 -0.0534668\n",
      " -0.05664062  0.18945312  0.37109375 -0.22070312  0.04638672  0.02612305\n",
      " -0.11474609  0.265625   -0.02453613  0.11083984 -0.02514648 -0.12060547\n",
      "  0.05297852  0.07128906  0.00063705 -0.36523438 -0.13769531 -0.12890625]\n"
     ]
    }
   ],
   "source": [
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code below shows the distance between two words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.47969\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "w1 = model['king']\n",
    "w2 = model['queen']\n",
    "\n",
    "dist = np.linalg.norm(w1-w2)\n",
    "\n",
    "print(dist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows the classic word2vec equation of **queen = (king - man) + female**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('queen', 0.7118192911148071),\n",
       " ('monarch', 0.6189674139022827),\n",
       " ('princess', 0.5902431607246399),\n",
       " ('crown_prince', 0.5499460697174072),\n",
       " ('prince', 0.5377321243286133),\n",
       " ('kings', 0.5236844420433044),\n",
       " ('Queen_Consort', 0.5235945582389832),\n",
       " ('queens', 0.5181134343147278),\n",
       " ('sultan', 0.5098593235015869),\n",
       " ('monarchy', 0.5087411999702454)]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.most_similar(positive=['woman', 'king'], negative=['man'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "The following code shows which item does not belong with the others."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dog'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.doesnt_match(\"house garage store dog\".split())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code shows the similarity between two words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.56335770280591491"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.similarity('iphone', 'android')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following code shows which words are most similar to the given one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('dogs', 0.8680490255355835),\n",
       " ('puppy', 0.8106428384780884),\n",
       " ('pit_bull', 0.780396044254303),\n",
       " ('pooch', 0.7627376317977905),\n",
       " ('cat', 0.7609457969665527),\n",
       " ('golden_retriever', 0.7500901818275452),\n",
       " ('German_shepherd', 0.7465174198150635),\n",
       " ('Rottweiler', 0.7437615394592285),\n",
       " ('beagle', 0.7418621778488159),\n",
       " ('pup', 0.7406911253929138)]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.most_similar('dog')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# More on LSTM\n",
    "\n",
    "* [The Unreasonable Effectiveness of Recurrent Neural Networks](http://karpathy.github.io/2015/05/21/rnn-effectiveness/)\n",
    "* [LSTM Music](https://www.youtube.com/watch?v=0VTI1BBLydE)\n",
    "* [Natural Language Processing from Scratch](https://arxiv.org/abs/1103.0398)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}