examples/tutorials/03_deeppavlov_gobot.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You can also run the notebook in [COLAB](https://colab.research.google.com/github/deepmipt/DeepPavlov/blob/master/examples/tutorials/03_deeppavlov_gobot.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip3 install deeppavlov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "from pprint import pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import deeppavlov"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**: \"go_bot\" model trains faster on a CPU, so let's ignore existing GPUs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda visible devices = ''\r\n"
     ]
    }
   ],
   "source": [
    "!export CUDA_VISIBLE_DEVICES=\"\"\n",
    "!echo \"cuda visible devices = '\"$CUDA_VISIBLE_DEVICES\"'\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hybrid goal-oriented bot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dialog bots are categorized into two types:\n",
    "\n",
    "1. **goal-oriented models **\n",
    "\n",
    "    (those who have to achieve some kind of a goal in the end of conversation: \n",
    "     - restaurant and flight booking,\n",
    "     - customer support service,\n",
    "     - etc.);\n",
    " \n",
    "2. **chit-chat models **\n",
    "\n",
    "   (those who chat just for fun, the longer bot speaks with you the better, example:\n",
    "    - \"replica\" mobile application).\n",
    "\n",
    "We will only dive into goal-oriented task specification."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![go bot architecture 00](img/bot_architecture00.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A classical dialog system consists of:\n",
    "\n",
    "1. **Natural Language Understanding component (NLU)**\n",
    "\n",
    " that is intended to \"understand\" human and represent it's \"understanding\" in a machine readable format. \n",
    "\n",
    " It takes an utterance text as input and converts to a dialog \"frame\".\n",
    "\n",
    " \"Frame\" may consist of:\n",
    "   - domain value (domain is some kind of \"a type of dialogs\");\n",
    "   - intent value (intent of current human utterance: \"welcome_message\", \"asking_weather\", etc.);\n",
    "   - entity slots (entities are mentioned by human \"location\", \"time\", etc.).\n",
    "\n",
    "2. **Dialogue Manager component (DM)**\n",
    "\n",
    " that is intended to decide what to respond. \n",
    "    \n",
    " It takes a filled by NLU frame and outputs action (it isn't a final text, it is a label). \n",
    "    \n",
    " For example, there may be actions: \"say_welcome\", \"say_goodbye\", \"ask_location\", \"give_weather\", etc.\n",
    "\n",
    "3. **Natural Language Generation component(NLG)**\n",
    "\n",
    " that is intended to convert action to an actual text response representation.\n",
    " \n",
    " For example, \"say_goodbye\" -> \"You are welcome!\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NLU "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![go bot architecture 01](img/bot_architecture01.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's consider a dialog system with NLU component that consists of a single Named Entity Recognition \n",
    "    component (or NER)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One of the previous tutorials introduced deeppavlov NER model and showed how to use it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DM & NLG"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tutorial is focused on how to implement\n",
    " - Dialogue Manager and\n",
    " - Natural Language Generator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will train the chatbot on a [Dialog State Tracking Chellenge 2](http://camdial.org/~mh521/dstc/) data.\n",
    "\n",
    "Let's download it first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:21:03.546 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from tmp/my_download_of_dstc2/dstc2-trn.jsonlist]\n",
      "2019-02-12 10:21:03.709 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from tmp/my_download_of_dstc2/dstc2-val.jsonlist]\n",
      "2019-02-12 10:21:03.824 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from tmp/my_download_of_dstc2/dstc2-tst.jsonlist]\n"
     ]
    }
   ],
   "source": [
    "from deeppavlov.dataset_readers.dstc2_reader import DSTC2DatasetReader\n",
    "\n",
    "data = DSTC2DatasetReader().read(data_path=\"tmp/my_download_of_dstc2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`DSTC2DatasetReader` downloaded the needed data and saved to disk.\n",
    "\n",
    "`DialogDatasetIterator` took the data as input and transformed it to batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from deeppavlov.dataset_iterators.dialog_iterator import DialogDatasetIterator\n",
    "\n",
    "batches_generator = DialogDatasetIterator(data, seed=1443, shuffle=True)\\\n",
    "                                         .gen_batches(batch_size=4, data_type='train')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-------------\n",
    "-------------\n",
    "   Let's take a closer look at a batch content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch = batches_generator.__next__()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each batch is a tuple of two elements:\n",
    "  - list of x's and\n",
    "  - list of y's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_batch, y_batch = batch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`x_batch` (and `y_batch`) consists of 4 samples. This is because `batch_size` was 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(x_batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One sample is a dialog. This is how one turn from a dialog looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----0th turn----\n",
      "(       {'intents': [], 'prev_resp_act': None, 'text': ''},\n",
      "        {       'act': 'welcomemsg',\n",
      "                'text': 'Hello, welcome to the Cambridge restaurant system. '\n",
      "                        'You can ask for restaurants by area, price range or '\n",
      "                        'food type. How may I help you?'})\n"
     ]
    }
   ],
   "source": [
    "dialog_id = 0\n",
    "dialog = [(x, y) for x, y in zip(x_batch[dialog_id], y_batch[dialog_id])]\n",
    "\n",
    "turn_id = 0\n",
    "print(\"----{}th turn----\".format(turn_id)) \n",
    "pprint(dialog[turn_id], indent=8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how the whole dialog looks (printing `'text'` parts of `x_batch` and `y_batch`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ":: \n",
      ">> Hello, welcome to the Cambridge restaurant system. You can ask for restaurants by area, price range or food type. How may I help you? \n",
      "\n",
      ":: traditional\n",
      ">> api_call area=\"dontcare\" food=\"traditional\" pricerange=\"dontcare\" \n",
      "\n",
      ":: traditional\n",
      ">> I am sorry but there is no traditional restaurant that matches your request. \n",
      "\n",
      ":: italian food\n",
      ">> What part of town do you have in mind? \n",
      "\n",
      ":: south\n",
      ">> api_call area=\"south\" food=\"italian\" pricerange=\"dontcare\" \n",
      "\n",
      ":: south\n",
      ">> Pizza hut cherry hinton is a nice place in the south of town serving tasty italian food. \n",
      "\n",
      ":: phone number\n",
      ">> The phone number of pizza hut cherry hinton is 01223 323737. \n",
      "\n",
      ":: post code\n",
      ">> The post code of pizza hut cherry hinton is C.B 1, 7 D.Y. \n",
      "\n",
      ":: thank you good bye\n",
      ">> You are welcome! \n",
      "\n"
     ]
    }
   ],
   "source": [
    "for turn in dialog:\n",
    "    x, y = turn\n",
    "    print('::', x['text']) \n",
    "    print('>>', y['text'], '\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### HowTo: DeepPavlov configs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "DeepPavlov uses json configs as a tool to configure data pipelines.\n",
    "\n",
    "Config has the following sections:\n",
    "     \n",
    " - **dataset_reader**\n",
    "   - configuration of dataset reader component (is responsible for data download and saving to disk);\n",
    "  \n",
    " - **dataset_iterator**\n",
    "   - configuration of dataset iterator component (is responsible for making batches (sequences) of data that will be further fed to pipe components);\n",
    "  \n",
    " - **metadata**\n",
    "   - extra info (urls for data download and telegram configuration);\n",
    "\n",
    " - **train**\n",
    "   - training process configuration (size of batches, number of training epochs, etc.);\n",
    "   \n",
    " - **chainer**\n",
    "   - specifies data flow (which components are run and in what order);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's construct a simple config that builds a dictionary of input sample tokens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_config = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **dataset_reader** -- configuration of dataset reader component (that is responsible for data download and saving to disk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "dstc2_reader_comp_config = {\n",
    "    'class_name': 'dstc2_reader',\n",
    "    'data_path': 'dstc2'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_config['dataset_reader'] = dstc2_reader_comp_config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **dataset_iterator** -- configuration of dataset iterator component (that is responsible for making batches (sequences) of data that will be further fed to pipe components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dialog_iterator_comp_config = {\n",
    "    'class_name': 'dialog_iterator'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_config['dataset_iterator'] = dialog_iterator_comp_config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **metadata** -- some extra info\n",
    "     - **metadata.download** -- a list of data which should be downloaded in order for config to work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "dstc2_download_config = {\n",
    "    'url': 'http://files.deeppavlov.ai/datasets/dstc2_v2.tar.gz',\n",
    "    'subdir': 'dstc2'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_config['metadata'] = {}\n",
    "vocab_config['metadata']['download'] = [\n",
    "    dstc2_download_config\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **train** -- training process configuration\n",
    "     \n",
    "We don't need to train anything now, just build (fit on whole dataset once) a dictionary, so \"train\" only specifies that metrics are empty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_config['train'] = {\n",
    "    'validate_best': False,\n",
    "    'test_best': False,\n",
    "    'class_name': 'fit_trainer'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - **chainer** specifies data flow:\n",
    " \n",
    "     - **chainer.in** -- is a list of input sample names (one data sample might consist of several variables);\n",
    "     - **chainer.in_y** -- is a list of input label names (each sample might have labels of different kind);\n",
    "     - **chainer.out** -- is a list of output prediction names (usually has the same length as \"chainer.in_y\");\n",
    "     \n",
    "X is only an utterance here.\n",
    "\n",
    "Y is empty (we don't need to train the dictionary like neural networks)\n",
    "\n",
    "There is no prediction for the config, nothing to predict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_config['chainer'] = {}\n",
    "vocab_config['chainer']['in'] = ['utterance']\n",
    "vocab_config['chainer']['in_y'] = []\n",
    "vocab_config['chainer']['out'] = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **chainer**\n",
    "     - **chainer.pipe** -- is a list of consequently run components. This is the place where you specify in which order and what kind of data will be fed to components. \n",
    "     \n",
    "Our pipe consists of one component -- \"default_vocab\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### HowTo: Component config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Component configs are always just a part of a global model config (described above).\n",
    "\n",
    "Config for any component contains the following **_required_** parameters:\n",
    " - **class_name** -- registered name of a component (it is a link to python component implementation)\n",
    " - **save_path** -- path to save the component (sometimes is not needed, for example, for tokenizers)\n",
    " - **load_path** -- path to load the component (sometimes is not needed, for examples, for tokenizers)\n",
    "\n",
    "and the following **_optional_** parameters:\n",
    " - **id** -- reference name for the component\n",
    " - **ref** -- \"id\" of a component that was previously initialized. It can be used instead of \"name\".\n",
    " - **fit\\_on** -- a list of data fields to fit on (it calls \\_\\_fit\\_\\_ method of the component)\n",
    " - **in** -- a list of data fields that are inputs during inference (prediction)\n",
    " - **out** -- a list of data fields that are outputs during inference (prediction)\n",
    " \n",
    " \n",
    "\"default_vocab\" component also has it's on unique parameters:\n",
    " - level -- on which level to operate ('token' level and 'char' (character) level are available)\n",
    " - tokenizer -- if input is a string, then it will be tokenized by the tokenizer, _optional parameter_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_comp_config = {\n",
    "    'class_name': 'default_vocab',\n",
    "    'save_path': 'vocabs/token.dict',\n",
    "    'load_path': 'vocabs/token.dict',\n",
    "    'fit_on': ['utterance'],\n",
    "    'level': 'token',\n",
    "    'tokenizer': {\n",
    "        'class_name': 'split_tokenizer'\n",
    "    },\n",
    "    'main': True\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_config['chainer']['pipe'] = [\n",
    "    vocab_comp_config\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To download \"dstc2_v2\" dataset use `deeppavlov.deep_download` script (you have to do it only once):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:21:12.184 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 205: Starting new HTTP connection (1): files.deeppavlov.ai:80\n",
      "2019-02-12 10:21:12.190 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 393: http://files.deeppavlov.ai:80 \"GET /datasets/dstc2_v2.tar.gz.md5 HTTP/1.1\" 200 260\n",
      "2019-02-12 10:21:12.200 INFO in 'deeppavlov.download'['download'] at line 115: Skipped http://files.deeppavlov.ai/datasets/dstc2_v2.tar.gz download because of matching hashes\n"
     ]
    }
   ],
   "source": [
    "from deeppavlov import deep_download # it is called \"deep\" in honor of \"Deep Pavlov\"\n",
    "\n",
    "deep_download(vocab_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All data and models are saved to `./dstc2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "dstc2_path = './dstc2'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data was downloaded to `dstc2_path`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> ls ./dstc2\n",
      "dstc2-templates.txt  dstc2-tst.jsonlist  resto.sqlite\n",
      "dstc2-trn.jsonlist   dstc2-val.jsonlist\n"
     ]
    }
   ],
   "source": [
    "# The command will only work for linux, do not panic otherwise -- it isn't something crucially important.\n",
    "# You can further just comment bash commands.\n",
    "!echo \"> ls $dstc2_path\"\n",
    "!ls $dstc2_path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's build our vocabulary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:21:13.800 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-trn.jsonlist]\n",
      "2019-02-12 10:21:13.992 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-val.jsonlist]\n",
      "2019-02-12 10:21:14.148 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-tst.jsonlist]\n",
      "2019-02-12 10:21:14.326 WARNING in 'deeppavlov.core.commands.train'['train'] at line 108: \"validate_best\" and \"test_best\" parameters are deprecated. Please, use \"evaluation_targets\" list instead\n",
      "[nltk_data] Downloading package punkt to /home/vimary/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n",
      "[nltk_data] Downloading package stopwords to /home/vimary/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package perluniprops to\n",
      "[nltk_data]     /home/vimary/nltk_data...\n",
      "[nltk_data]   Package perluniprops is already up-to-date!\n",
      "[nltk_data] Downloading package nonbreaking_prefixes to\n",
      "[nltk_data]     /home/vimary/nltk_data...\n",
      "[nltk_data]   Package nonbreaking_prefixes is already up-to-date!\n",
      "2019-02-12 10:21:14.972 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:21:14.996 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 163: [saving vocabulary to /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:21:14.998 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:21:15.0 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<deeppavlov.core.common.chainer.Chainer at 0x7f1a5c1caf98>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from deeppavlov import train_model\n",
    "\n",
    "train_model(vocab_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vocabulary was built on data and saved to disk.\n",
    "\n",
    "`save_path = 'vocabs/token.dict'` and component files are saved to `./vocabs/token.dict`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocabs_path = './vocabs'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> ls ./vocabs\n",
      "token.dict\n"
     ]
    }
   ],
   "source": [
    "!echo \"> ls $vocabs_path\"\n",
    "!ls $vocabs_path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the content of the saved \"token.dict\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> head ./vocabs/token.dict\n",
      "cheap\t391\n",
      "restaurant\t1179\n",
      "any\t259\n",
      "south\t306\n",
      "address\t781\n",
      "phone\t819\n",
      "number\t825\n",
      "thank\t998\n",
      "you\t1055\n",
      "good\t891\n"
     ]
    }
   ],
   "source": [
    "!echo \"> head $vocabs_path/token.dict\"\n",
    "!head $vocabs_path/token.dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using trained component"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use built vocabulary by initializing it with `build_model`.\n",
    "\n",
    "We need to add `in` and `out` to component configuration ( to know what are inputs and outputs during prediction ) :\n",
    " - **in** -- a list of data fields that are inputs during inference (prediction)\n",
    " - **out** -- a list of data fields that are outputs during inference (prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_comp_config['in'] = ['utterance']\n",
    "vocab_comp_config['out'] = ['utterance_token_indices']\n",
    "\n",
    "vocab_config['chainer']['pipe'] = [\n",
    "    vocab_comp_config\n",
    "]\n",
    "vocab_config['chainer']['out'] = ['utterance_token_indices']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:21:17.378 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n"
     ]
    }
   ],
   "source": [
    "from deeppavlov import build_model\n",
    "\n",
    "model = build_model(vocab_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model expects a list of samples (batch) as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[141]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(['hi'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model `gobot_dstc2_simple`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's train a simple goal-oriented bot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from deeppavlov import build_model, deep_download"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"dataset_reader\", \"dataset_iterator\" and \"metadata\" will be the same as for vocabulary only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_config = {}\n",
    "\n",
    "simple_config['dataset_reader'] = dstc2_reader_comp_config\n",
    "simple_config['dataset_iterator'] = dialog_iterator_comp_config\n",
    "simple_config['metadata'] = {}\n",
    "simple_config['metadata']['download'] = [\n",
    "    dstc2_download_config\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "X here is a dict `'x'` containing context 'text', 'intents', db_result', 'prev_resp_act'\n",
    "\n",
    "Y here is a dict `'y'` containing response 'act' and 'text'\n",
    "\n",
    "Prediction `'y_predicted'` here will be only 'text'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_config['chainer'] = {}\n",
    "simple_config['chainer']['in'] = ['x']\n",
    "simple_config['chainer']['in_y'] =['y']\n",
    "simple_config['chainer']['out'] = ['y_predicted']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The bot consists (`pipe` section) of two components:\n",
    "- **`default_vocab`** (or DefaultVocabulary) component that \n",
    "\n",
    "    - remembers all tokens from user utterances. \n",
    "    - `DefaultVocabulary.__call__` method inputs batch of tokens and outputs their indeces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vocabulary component will be the same as before, but let's add reference to component using `id` \n",
    "- **id** -- reference name for the component"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_comp_config = {\n",
    "    'class_name': 'default_vocab',\n",
    "    'id': 'token_vocab',\n",
    "    'load_path': 'vocabs/token.dict',\n",
    "    'save_path': 'vocabs/token.dict',\n",
    "    'fit_on': ['x'],\n",
    "    'level': 'token',\n",
    "    'tokenizer': {\n",
    "        'class_name': 'split_tokenizer'\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding vocabulary to chainer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_config['chainer']['pipe'] = []\n",
    "simple_config['chainer']['pipe'].append(vocab_comp_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **`go_bot`** (or GoalOrientedBot) component that\n",
    "    - calls `slot_filler` that for user utterance outputs mentioned slots \n",
    "        (for example, \"i want cheap food\" -> {'pricerange': 'cheap'})\n",
    "    - updates dialog state with `tracker` (DialogStateTracker)\n",
    "        \n",
    "          (for example, if old state was {'location': 'north'}, \n",
    "          and current slots are {'pricerange': 'cheap'}, \n",
    "          then new dialog state will be {'location': 'north', 'pricerange': 'cheap'})\n",
    "    - converts user utterance in string format (`x`) to tokens with `tokenizer`\n",
    "\n",
    "          (for example, \"hi, i want some cheap food\" -> ['hi', ',', 'i', 'want', 'some', 'cheap', 'food'])\n",
    "    - then embeds the tokens with bag-of-words using `bow_embedder`(if not None) and `word_vocab`\n",
    "\n",
    "          (for example, \"cheap\" -> [1, 0, 0, 0, .., 0])\n",
    "    - embeds the utterance with continuous `embedder` (if not None) as a mean of embeddings of utterance tokens\n",
    "        \n",
    "          (for example, \"i\" -> [0.1231, 0.23423, .., 0.03489])\n",
    "    - concatenates embeddings and passes it as an input to a recurrent neural network (RNN)\n",
    "    - trains RNN (with LongShortTermMemory (LSTM) as a core graph) that outputs an action label\n",
    "    - loads templates (mapping from labels to string) using `template_path` and `template_type` and converts action label to string\n",
    "        \n",
    "          (for example, \"bye_msg\" -> \"You are welcome!\")\n",
    "    - fills result string with slot values from dialog state\n",
    "        \n",
    "          (for example, if\n",
    "           dialog state is equal to {'pricerange': 'cheap'}\n",
    "           and output string is \"There are no restaurants in a #pricerange pricerange\"\n",
    "           then the result response will be \"There are no restaurants in a cheap pricerange\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_comp_config = {\n",
    "    'class_name': 'go_bot',\n",
    "    'in': ['x'],\n",
    "    'in_y': ['y'],\n",
    "    'out': ['y_predicted'],\n",
    "    'load_path': 'gobot_dstc2_simple/model',\n",
    "    'save_path': 'gobot_dstc2_simple/model',\n",
    "    'word_vocab': None,\n",
    "    'bow_embedder': None,\n",
    "    'embedder': None,\n",
    "    'slot_filler': None,\n",
    "    'template_path': 'dstc2/dstc2-templates.txt',\n",
    "    'template_type': 'DualTemplate',\n",
    "    'database': None,\n",
    "    'api_call_action': 'api_call',\n",
    "    'network_parameters': {\n",
    "      'dense_size': 64,\n",
    "      'hidden_size': 128,\n",
    "      'learning_rate': 0.002,\n",
    "      'attention_mechanism': None\n",
    "    },\n",
    "    'tokenizer': {\n",
    "        'class_name': 'stream_spacy_tokenizer',\n",
    "        'lowercase': False\n",
    "    },\n",
    "    'tracker': {\n",
    "        'class_name': 'featurized_tracker',\n",
    "        'slot_names': ['pricerange', 'this', 'area', 'food', 'name']\n",
    "    },\n",
    "    'main': True,\n",
    "    'debug': False\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how we use vocabulary by reference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_comp_config['word_vocab'] = '#token_vocab'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also initialize a bag-of-words one-hot encoder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_comp_config['bow_embedder'] = {\n",
    "    \"class_name\": \"bow\",\n",
    "    \"depth\": \"#token_vocab.__len__()\", # here we referenced __len__() method of token_vocab component\n",
    "    \"with_counts\": True\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Announcing slot filler component.\n",
    "We assume that slot filler is already trained, and use it by referencing it's config."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from deeppavlov import configs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "slot_filler_comp_config = {\n",
    "    'config_path': configs.ner.slotfill_dstc2\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding slot filler to bot component:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_comp_config['slot_filler'] = slot_filler_comp_config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding `bot_comp_config` to `pipe`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_config['chainer']['pipe'].append(bot_comp_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neural network (in the bot) is trained in epochs, and needs data in the form of batches.\n",
    "\n",
    "That is why we are now filling \"train\" section with training parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **train** -- training process configuration\n",
    "     - **train.batch_size** is a number of samples in a batch (feeded to the network during one training step)\n",
    "     - **train.epochs** is a number of iterations over dataset during training\n",
    "     - **train.log_every_n_batches** and **train.log_every_n_epochs** control frequency of logging messages\n",
    "     - **train.metrics** is a list of metrics used to validate our performance\n",
    "     - **train.val_every_n_epochs** describes how often we calculate metrics on `valid` data split\n",
    "     - **train.validation_patience** is a number of epochs without metric improvement on `valid` data that we are able to endure =)\n",
    "     - **validate_best** is a flag that controles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_bot_train_config = {\n",
    "    'batch_size': 4,\n",
    "    'epochs': 2,\n",
    "    'log_every_n_batches': -1,\n",
    "    'log_every_n_epochs': 1,\n",
    "    'metrics': ['per_item_dialog_accuracy'],\n",
    "    'val_every_n_epochs': 1,\n",
    "    'validation_patience': 20,\n",
    "    'validate_best': False,\n",
    "    'test_best': False\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_config['train'] = simple_bot_train_config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`train.epochs` is set to '2' for now, if you intend to train a smarter model, you should increase it (a range from 10 to 200 epochs is recommended)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:21:35.699 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 205: Starting new HTTP connection (1): files.deeppavlov.ai:80\n",
      "2019-02-12 10:21:35.706 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 393: http://files.deeppavlov.ai:80 \"GET /deeppavlov_data/slotfill_dstc2.tar.gz.md5 HTTP/1.1\" 200 442\n",
      "2019-02-12 10:21:35.712 INFO in 'deeppavlov.download'['download'] at line 115: Skipped http://files.deeppavlov.ai/deeppavlov_data/slotfill_dstc2.tar.gz download because of matching hashes\n"
     ]
    }
   ],
   "source": [
    "deep_download(slot_filler_comp_config['config_path'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:21:38.732 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-trn.jsonlist]\n",
      "2019-02-12 10:21:38.967 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-val.jsonlist]\n",
      "2019-02-12 10:21:39.49 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-tst.jsonlist]\n",
      "2019-02-12 10:21:39.262 WARNING in 'deeppavlov.core.commands.train'['train'] at line 108: \"validate_best\" and \"test_best\" parameters are deprecated. Please, use \"evaluation_targets\" list instead\n",
      "2019-02-12 10:21:39.263 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:21:39.282 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 163: [saving vocabulary to /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:21:42.670 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:21:42.673 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "Using TensorFlow backend.\n",
      "2019-02-12 10:21:42.914 WARNING in 'tensorflow'['tf_logging'] at line 125: From /home/vimary/ipavlov/Pilot/deeppavlov/models/ner/network.py:260: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See @{tf.nn.softmax_cross_entropy_with_logits_v2}.\n",
      "\n",
      "2019-02-12 10:21:43.939 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:21:43.953 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:21:44.351 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:21:44.352 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:21:44.353 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 511\n",
      "2019-02-12 10:21:44.959 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 243: [initializing `GoalOrientedBot` from scratch]\n",
      "2019-02-12 10:22:06.469 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.0067\n",
      "2019-02-12 10:22:06.470 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:22:06.470 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model]\n",
      "2019-02-12 10:22:06.546 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model.json]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.0067}, \"time_spent\": \"0:00:22\", \"epochs_done\": 0, \"batches_seen\": 0, \"train_examples_seen\": 0, \"impatience\": 0, \"patience_limit\": 20}}\n",
      "{\"train\": {\"eval_examples_count\": 4, \"metrics\": {\"per_item_dialog_accuracy\": 0.6452}, \"time_spent\": \"0:00:43\", \"epochs_done\": 1, \"batches_seen\": 242, \"train_examples_seen\": 967, \"loss\": 1.1027095528427235, \"learning_rate\": 0.002, \"momentum\": 0.9}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:22:48.356 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.451\n",
      "2019-02-12 10:22:48.357 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:22:48.357 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model]\n",
      "2019-02-12 10:22:48.417 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model.json]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.451}, \"time_spent\": \"0:01:04\", \"epochs_done\": 1, \"batches_seen\": 242, \"train_examples_seen\": 967, \"impatience\": 0, \"patience_limit\": 20}}\n",
      "{\"train\": {\"eval_examples_count\": 4, \"metrics\": {\"per_item_dialog_accuracy\": 0.52}, \"time_spent\": \"0:01:25\", \"epochs_done\": 2, \"batches_seen\": 484, \"train_examples_seen\": 1934, \"loss\": 0.5463642796947936, \"learning_rate\": 0.002, \"momentum\": 0.9}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:23:30.618 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 169: Did not improve on the per_item_dialog_accuracy of 0.451\n",
      "2019-02-12 10:23:30.649 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:23:30.651 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:23:30.653 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.4454}, \"time_spent\": \"0:01:46\", \"epochs_done\": 2, \"batches_seen\": 484, \"train_examples_seen\": 1934, \"impatience\": 1, \"patience_limit\": 20}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:23:31.173 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:23:31.187 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:23:31.461 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:23:31.461 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:23:31.462 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 511\n",
      "2019-02-12 10:23:32.100 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 240: [initializing `GoalOrientedBot` from saved]\n",
      "2019-02-12 10:23:32.101 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 714: [loading parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model.json]\n",
      "2019-02-12 10:23:32.102 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model]\n",
      "2019-02-12 10:23:32.109 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model\n",
      "2019-02-12 10:23:32.126 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:23:32.128 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:23:32.131 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:23:32.677 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:23:32.690 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:23:32.986 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:23:32.987 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:23:32.987 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 511\n",
      "2019-02-12 10:23:33.422 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 240: [initializing `GoalOrientedBot` from saved]\n",
      "2019-02-12 10:23:33.423 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 714: [loading parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model.json]\n",
      "2019-02-12 10:23:33.425 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model]\n",
      "2019-02-12 10:23:33.432 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<deeppavlov.core.common.chainer.Chainer at 0x7f1927518630>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_model(simple_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's comminicate with the resulting bot. \"exit\" message initiates end of dialogue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:23:33.451 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:23:33.455 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:23:33.458 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:23:34.219 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:23:34.234 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:23:34.498 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:23:34.499 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:23:34.499 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 511\n",
      "2019-02-12 10:23:34.987 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 240: [initializing `GoalOrientedBot` from saved]\n",
      "2019-02-12 10:23:34.988 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 714: [loading parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model.json]\n",
      "2019-02-12 10:23:34.990 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model]\n",
      "2019-02-12 10:23:35.0 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_simple/model\n"
     ]
    }
   ],
   "source": [
    "model = build_model(simple_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:23:35.110 WARNING in 'deeppavlov.models.go_bot.network'['network'] at line 471: No database specified.\n",
      "2019-02-12 10:23:35.110 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 472: Made api_call with {'pricerange': 'cheap', 'food': 'italian', 'area': 'north'}, got 0 results.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Sorry there is no italian restaurant in the north of town.']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(['hi, i want some cheap italian food in the north of town'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:23:35.127 WARNING in 'deeppavlov.models.go_bot.network'['network'] at line 471: No database specified.\n",
      "2019-02-12 10:23:35.128 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 472: Made api_call with {'pricerange': 'cheap', 'food': 'italian', 'area': 'north'}, got 0 results.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['Sorry there is no italian restaurant in the north of town.']"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(['thanks, bye'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.reset() # resetting dialog context to start a new dialog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> Hello, welcome to the Cambridge restaurant system. You can ask for restaurants by area, price range or food type. How may I help you?\n",
      ":: hi, i want cheap food\n",
      ">> Hello, welcome to the Cambridge restaurant system. You can ask for restaurants by area, price range or food type. How may I help you?\n",
      ":: hi\n",
      ">> Hello, welcome to the Cambridge restaurant system. You can ask for restaurants by area, price range or food type. How may I help you?\n",
      ":: you're very silly for now\n",
      ">> Hello, welcome to the Cambridge restaurant system. You can ask for restaurants by area, price range or food type. How may I help you?\n",
      ":: exit\n"
     ]
    }
   ],
   "source": [
    "# if the cell is running, please do not run other cells in parallel -- there is a possibility of a hangup\n",
    "\n",
    "utterance = \"\"\n",
    "while utterance != 'exit':\n",
    "    print(\">> \" + model([utterance])[0])\n",
    "    utterance = input(':: ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model couldn't fill some slots. For example, #address, #phone, #postcode of a restaurant couldn't be inferred from user utterance. \n",
    "\n",
    "A list of available restaurants is required."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model `gobot_dstc2_db`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's now add a database with restaurants and train a new model:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initializing new config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "db_config = copy.deepcopy(simple_config)\n",
    "\n",
    "db_config['chainer']['pipe'] = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating database component config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "db_comp_config = {\n",
    "    'class_name': 'sqlite_database',\n",
    "    'id': 'restaurant_database', \n",
    "    'save_path': 'dstc2/resto.sqlite',\n",
    "    'primary_keys': ['name'],\n",
    "    'table_name': 'mytable'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding vocab and database components to pipe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "db_config['chainer']['pipe'].append(vocab_comp_config)\n",
    "db_config['chainer']['pipe'].append(db_comp_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initializing bot component config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_with_db_comp_config = copy.deepcopy(bot_comp_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**WARNING:** Do no forget to change `load_path` and `save_path` in neural network configuration when \n",
    "             training a new modification. Otherwise previous model's files will be overwritten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_with_db_comp_config['load_path'] = 'gobot_dstc2_db/model'\n",
    "bot_with_db_comp_config['save_path'] = 'gobot_dstc2_db/model'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding database to bot component config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_with_db_comp_config['database'] = '#restaurant_database'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Addind bot component to pipe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "db_config['chainer']['pipe'].append(bot_with_db_comp_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new model now updates dialog state not only with entity values mentioned by user (\"i want cheap food\" -> {'pricerange': 'cheap'}), but also with restaurant info taken from sql database of restaurants.\n",
    "\n",
    "Model has a special action `api_call_action`, which initiates a request to sql database with current dialog state and thus receives info of a single matching restaurant.\n",
    "\n",
    "So now such slots as #address, #phone and #postcode can be filled in bot responses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:24:04.591 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-trn.jsonlist]\n",
      "2019-02-12 10:24:04.708 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-val.jsonlist]\n",
      "2019-02-12 10:24:05.5 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-tst.jsonlist]\n",
      "2019-02-12 10:24:05.99 WARNING in 'deeppavlov.core.commands.train'['train'] at line 108: \"validate_best\" and \"test_best\" parameters are deprecated. Please, use \"evaluation_targets\" list instead\n",
      "2019-02-12 10:24:05.100 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:24:05.118 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 163: [saving vocabulary to /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:24:05.121 WARNING in 'deeppavlov.core.models.serializable'['serializable'] at line 51: No load path is set for Sqlite3Database!\n",
      "2019-02-12 10:24:05.121 INFO in 'deeppavlov.core.data.sqlite_database'['sqlite_database'] at line 63: Loading database from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/resto.sqlite.\n",
      "2019-02-12 10:24:05.125 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:24:05.128 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:24:05.637 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:24:05.651 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:24:05.905 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:24:05.906 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:24:05.906 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 511\n",
      "2019-02-12 10:24:06.654 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 243: [initializing `GoalOrientedBot` from scratch]\n",
      "2019-02-12 10:24:27.898 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.0106\n",
      "2019-02-12 10:24:27.899 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:24:27.899 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model]\n",
      "2019-02-12 10:24:27.968 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model.json]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.0106}, \"time_spent\": \"0:00:22\", \"epochs_done\": 0, \"batches_seen\": 0, \"train_examples_seen\": 0, \"impatience\": 0, \"patience_limit\": 20}}\n",
      "{\"train\": {\"eval_examples_count\": 4, \"metrics\": {\"per_item_dialog_accuracy\": 0.5}, \"time_spent\": \"0:00:43\", \"epochs_done\": 1, \"batches_seen\": 242, \"train_examples_seen\": 967, \"loss\": 1.101250118460537, \"learning_rate\": 0.002, \"momentum\": 0.9}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:25:10.20 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.4264\n",
      "2019-02-12 10:25:10.21 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:25:10.22 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model]\n",
      "2019-02-12 10:25:10.80 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model.json]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.4264}, \"time_spent\": \"0:01:04\", \"epochs_done\": 1, \"batches_seen\": 242, \"train_examples_seen\": 967, \"impatience\": 0, \"patience_limit\": 20}}\n",
      "{\"train\": {\"eval_examples_count\": 4, \"metrics\": {\"per_item_dialog_accuracy\": 0.6512}, \"time_spent\": \"0:01:25\", \"epochs_done\": 2, \"batches_seen\": 484, \"train_examples_seen\": 1934, \"loss\": 0.5439255740647474, \"learning_rate\": 0.002, \"momentum\": 0.9}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:25:52.486 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.4468\n",
      "2019-02-12 10:25:52.487 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:25:52.487 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model]\n",
      "2019-02-12 10:25:52.553 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model.json]\n",
      "2019-02-12 10:25:52.588 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:25:52.590 WARNING in 'deeppavlov.core.models.serializable'['serializable'] at line 48: No load path is set for Sqlite3Database in 'infer' mode. Using save path instead\n",
      "2019-02-12 10:25:52.590 INFO in 'deeppavlov.core.data.sqlite_database'['sqlite_database'] at line 63: Loading database from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/resto.sqlite.\n",
      "2019-02-12 10:25:52.592 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:25:52.595 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.4468}, \"time_spent\": \"0:01:46\", \"epochs_done\": 2, \"batches_seen\": 484, \"train_examples_seen\": 1934, \"impatience\": 0, \"patience_limit\": 20}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:25:53.105 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:25:53.118 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:25:53.379 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:25:53.380 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:25:53.380 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 511\n",
      "2019-02-12 10:25:53.844 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 240: [initializing `GoalOrientedBot` from saved]\n",
      "2019-02-12 10:25:53.844 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 714: [loading parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model.json]\n",
      "2019-02-12 10:25:53.845 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model]\n",
      "2019-02-12 10:25:53.854 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model\n",
      "2019-02-12 10:25:53.891 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:25:53.892 WARNING in 'deeppavlov.core.models.serializable'['serializable'] at line 48: No load path is set for Sqlite3Database in 'infer' mode. Using save path instead\n",
      "2019-02-12 10:25:53.893 INFO in 'deeppavlov.core.data.sqlite_database'['sqlite_database'] at line 63: Loading database from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/resto.sqlite.\n",
      "2019-02-12 10:25:53.895 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:25:53.898 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:25:54.428 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:25:54.441 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:25:54.696 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:25:54.696 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:25:54.697 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 511\n",
      "2019-02-12 10:25:55.181 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 240: [initializing `GoalOrientedBot` from saved]\n",
      "2019-02-12 10:25:55.182 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 714: [loading parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model.json]\n",
      "2019-02-12 10:25:55.182 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model]\n",
      "2019-02-12 10:25:55.191 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_db/model\n"
     ]
    }
   ],
   "source": [
    "####### Instead of\n",
    "#\n",
    "# train_model(db_config)\n",
    "#\n",
    "# model = build_model(db_config)\n",
    "#\n",
    "####### we can just do\n",
    "\n",
    "model = train_model(db_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> Hello, welcome to the Cambridge restaurant system. You can ask for restaurants by area, price range or food type. How may I help you?\n",
      ":: Hi! I want some cheap food in the north of town\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:26:22.244 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 472: Made api_call with {'pricerange': 'cheap', 'area': 'north'}, got 2 results.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: ok, give me their phone number\n",
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: give me the address, please\n",
      ">> Sure, da vinci pizzeria is on 20 milton road chesterton.\n",
      ":: ok, thanks\n",
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: bye\n",
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: exit\n"
     ]
    }
   ],
   "source": [
    "# if the cell is running, please do not run other cells in parallel -- there is a possibility of a hangup\n",
    "\n",
    "model.reset() # starting new dialog\n",
    "\n",
    "utterance = \"\"\n",
    "while utterance != 'exit':\n",
    "    print(\">> \" + model([utterance])[0])\n",
    "    utterance = input(':: ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model `gobot_dstc2_emb`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's train a goal-oriented bot with fasttext embeddings:\n",
    "\n",
    "**NOTICE:** YOU NEED TO CONSTRUCT A NEW CONFIG YOURSELF\n",
    "\n",
    "Ensure that fastText is installed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install pybind11==2.2.3 \n",
    "!pip install git+https://github.com/deepmipt/fastText.git#egg=fastText==0.8.22"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initalizing new config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "emb_config = copy.deepcopy(db_config)\n",
    "\n",
    "emb_config['chainer']['pipe'] = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding vocab and database components to chainer pipe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "emb_config['chainer']['pipe'].append(vocab_comp_config)\n",
    "emb_config['chainer']['pipe'].append(db_comp_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initalizing embedder component:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedder_comp_config = {\n",
    "    'id': 'my_embedder',\n",
    "    'class_name': 'fasttext',\n",
    "    'load_path': 'embeddings/dstc2_fastText_model.bin',\n",
    "    'save_path': 'embeddings/dstc2_fastText_model.bin',\n",
    "    'dim': 100\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding embedder component to chainer pipe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "emb_config['chainer']['pipe'].append(embedder_comp_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initializing bot component config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_with_embedder_comp_config = copy.deepcopy(bot_with_db_comp_config)\n",
    "\n",
    "bot_with_embedder_comp_config['load_path'] = 'gobot_dstc2_emb/model'\n",
    "bot_with_embedder_comp_config['save_path'] = 'gobot_dstc2_emb/model'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding #my_embedder to bot_with_embedder_comp_config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_with_embedder_comp_config['embedder'] = '#my_embedder'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding bot_with_embedder_comp_config to chainer pipe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "emb_config['chainer']['pipe'].append(bot_with_embedder_comp_config)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are download urls for new required data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedder_required_data = {\n",
    "    'url': 'http://files.deeppavlov.ai/deeppavlov_data/embeddings/dstc2_fastText_model.bin',\n",
    "    'subdir': 'embeddings'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "emb_config['metadata']['download'].append(embedder_required_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As far as we are now using embeddings, we added a file named `dstc2_fastText_model.bin` to `metadata.download` section. \n",
    "\n",
    "Let's run data loading again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:27:17.345 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 205: Starting new HTTP connection (1): files.deeppavlov.ai:80\n",
      "2019-02-12 10:27:17.351 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 393: http://files.deeppavlov.ai:80 \"GET /deeppavlov_data/slotfill_dstc2.tar.gz.md5 HTTP/1.1\" 200 442\n",
      "2019-02-12 10:27:17.354 INFO in 'deeppavlov.download'['download'] at line 115: Skipped http://files.deeppavlov.ai/deeppavlov_data/slotfill_dstc2.tar.gz download because of matching hashes\n",
      "2019-02-12 10:27:17.355 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 205: Starting new HTTP connection (1): files.deeppavlov.ai:80\n",
      "2019-02-12 10:27:17.358 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 393: http://files.deeppavlov.ai:80 \"GET /datasets/dstc2_v2.tar.gz.md5 HTTP/1.1\" 200 260\n",
      "2019-02-12 10:27:17.369 INFO in 'deeppavlov.download'['download'] at line 115: Skipped http://files.deeppavlov.ai/datasets/dstc2_v2.tar.gz download because of matching hashes\n",
      "2019-02-12 10:27:17.370 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 205: Starting new HTTP connection (1): files.deeppavlov.ai:80\n",
      "2019-02-12 10:27:17.373 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 393: http://files.deeppavlov.ai:80 \"GET /deeppavlov_data/embeddings/dstc2_fastText_model.bin.md5 HTTP/1.1\" 200 59\n",
      "2019-02-12 10:27:17.376 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 205: Starting new HTTP connection (1): files.deeppavlov.ai:80\n",
      "2019-02-12 10:27:17.473 DEBUG in 'urllib3.connectionpool'['connectionpool'] at line 393: http://files.deeppavlov.ai:80 \"GET /deeppavlov_data/embeddings/dstc2_fastText_model.bin HTTP/1.1\" 200 800203996\n",
      "2019-02-12 10:27:17.475 INFO in 'deeppavlov.core.data.utils'['utils'] at line 64: Downloading from http://files.deeppavlov.ai/deeppavlov_data/embeddings/dstc2_fastText_model.bin to /home/vimary/ipavlov/Pilot/examples/tutorials/embeddings/dstc2_fastText_model.bin\n",
      "100%|██████████| 800M/800M [00:13<00:00, 59.7MB/s] \n"
     ]
    }
   ],
   "source": [
    "deep_download(emb_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:27:30.882 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-trn.jsonlist]\n",
      "2019-02-12 10:27:31.397 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-val.jsonlist]\n",
      "2019-02-12 10:27:31.478 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-tst.jsonlist]\n",
      "2019-02-12 10:27:31.571 WARNING in 'deeppavlov.core.commands.train'['train'] at line 108: \"validate_best\" and \"test_best\" parameters are deprecated. Please, use \"evaluation_targets\" list instead\n",
      "2019-02-12 10:27:31.572 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:27:31.590 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 163: [saving vocabulary to /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:27:31.591 WARNING in 'deeppavlov.core.models.serializable'['serializable'] at line 51: No load path is set for Sqlite3Database!\n",
      "2019-02-12 10:27:31.592 INFO in 'deeppavlov.core.data.sqlite_database'['sqlite_database'] at line 63: Loading database from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/resto.sqlite.\n",
      "2019-02-12 10:27:31.595 INFO in 'deeppavlov.models.embedders.fasttext_embedder'['fasttext_embedder'] at line 52: [loading fastText embeddings from `/home/vimary/ipavlov/Pilot/examples/tutorials/embeddings/dstc2_fastText_model.bin`]\n",
      "2019-02-12 10:27:32.332 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:27:32.336 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:27:33.114 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:27:33.128 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:27:33.376 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:27:33.377 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:27:33.377 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 611\n",
      "2019-02-12 10:27:33.807 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 243: [initializing `GoalOrientedBot` from scratch]\n",
      "2019-02-12 10:27:55.681 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.01\n",
      "2019-02-12 10:27:55.682 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:27:55.682 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model]\n",
      "2019-02-12 10:27:55.750 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model.json]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.01}, \"time_spent\": \"0:00:22\", \"epochs_done\": 0, \"batches_seen\": 0, \"train_examples_seen\": 0, \"impatience\": 0, \"patience_limit\": 20}}\n",
      "{\"train\": {\"eval_examples_count\": 4, \"metrics\": {\"per_item_dialog_accuracy\": 0.4545}, \"time_spent\": \"0:00:45\", \"epochs_done\": 1, \"batches_seen\": 242, \"train_examples_seen\": 967, \"loss\": 1.1537260356520818, \"learning_rate\": 0.002, \"momentum\": 0.9}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:28:38.916 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.4226\n",
      "2019-02-12 10:28:38.916 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:28:38.916 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model]\n",
      "2019-02-12 10:28:38.979 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model.json]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.4226}, \"time_spent\": \"0:01:06\", \"epochs_done\": 1, \"batches_seen\": 242, \"train_examples_seen\": 967, \"impatience\": 0, \"patience_limit\": 20}}\n",
      "{\"train\": {\"eval_examples_count\": 4, \"metrics\": {\"per_item_dialog_accuracy\": 0.6667}, \"time_spent\": \"0:01:28\", \"epochs_done\": 2, \"batches_seen\": 484, \"train_examples_seen\": 1934, \"loss\": 0.5818639241836288, \"learning_rate\": 0.002, \"momentum\": 0.9}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:29:22.27 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.4807\n",
      "2019-02-12 10:29:22.28 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:29:22.28 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model]\n",
      "2019-02-12 10:29:22.90 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model.json]\n",
      "2019-02-12 10:29:22.143 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:29:22.144 WARNING in 'deeppavlov.core.models.serializable'['serializable'] at line 48: No load path is set for Sqlite3Database in 'infer' mode. Using save path instead\n",
      "2019-02-12 10:29:22.144 INFO in 'deeppavlov.core.data.sqlite_database'['sqlite_database'] at line 63: Loading database from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/resto.sqlite.\n",
      "2019-02-12 10:29:22.145 INFO in 'deeppavlov.models.embedders.fasttext_embedder'['fasttext_embedder'] at line 52: [loading fastText embeddings from `/home/vimary/ipavlov/Pilot/examples/tutorials/embeddings/dstc2_fastText_model.bin`]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.4807}, \"time_spent\": \"0:01:49\", \"epochs_done\": 2, \"batches_seen\": 484, \"train_examples_seen\": 1934, \"impatience\": 0, \"patience_limit\": 20}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:29:22.843 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:29:22.846 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:29:23.348 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:29:23.362 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:29:23.606 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:29:23.606 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:29:23.607 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 611\n",
      "2019-02-12 10:29:24.40 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 240: [initializing `GoalOrientedBot` from saved]\n",
      "2019-02-12 10:29:24.41 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 714: [loading parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model.json]\n",
      "2019-02-12 10:29:24.42 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model]\n",
      "2019-02-12 10:29:24.50 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model\n",
      "2019-02-12 10:29:24.99 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:29:24.100 WARNING in 'deeppavlov.core.models.serializable'['serializable'] at line 48: No load path is set for Sqlite3Database in 'infer' mode. Using save path instead\n",
      "2019-02-12 10:29:24.101 INFO in 'deeppavlov.core.data.sqlite_database'['sqlite_database'] at line 63: Loading database from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/resto.sqlite.\n",
      "2019-02-12 10:29:24.101 INFO in 'deeppavlov.models.embedders.fasttext_embedder'['fasttext_embedder'] at line 52: [loading fastText embeddings from `/home/vimary/ipavlov/Pilot/examples/tutorials/embeddings/dstc2_fastText_model.bin`]\n",
      "2019-02-12 10:29:24.798 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:29:24.801 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:29:25.652 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:29:25.665 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:29:25.900 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:29:25.901 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:29:25.901 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 611\n",
      "2019-02-12 10:29:26.366 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 240: [initializing `GoalOrientedBot` from saved]\n",
      "2019-02-12 10:29:26.367 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 714: [loading parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model.json]\n",
      "2019-02-12 10:29:26.368 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model]\n",
      "2019-02-12 10:29:26.376 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_emb/model\n"
     ]
    }
   ],
   "source": [
    "model = train_model(emb_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> Hello, welcome to the Cambridge restaurant system. You can ask for restaurants by area, price range or food type. How may I help you?\n",
      ":: Hi, i want some cheap food in the north, please\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:29:35.995 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 472: Made api_call with {'pricerange': 'cheap', 'area': 'north'}, got 2 results.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: what type of food is there?\n",
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: give me their phone number \n",
      ">> The phone number of da vinci pizzeria is 01223 351707.\n",
      ":: and address too\n",
      ">> Sure, da vinci pizzeria is on 20 milton road chesterton.\n",
      ":: thanks\n",
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: bye\n",
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: exit\n"
     ]
    }
   ],
   "source": [
    "# if the cell is running, please do not run other cells in parallel -- there is a possibility of a hangup\n",
    "\n",
    "model.reset() # starting new dialog\n",
    "\n",
    "utterance = \"\"\n",
    "while utterance != 'exit':\n",
    "    print(\">> \" + model([utterance])[0])\n",
    "    utterance = input(':: ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix A\n",
    "### Additional materials"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [DataFest Presentation (RU)](https://docs.google.com/presentation/d/1PBPQp-wgQ6aRbm3MsuyGYB_TVg2c7Bf89lhdhbMtC2k)\n",
    "- [CISS Video Lecture](https://youtu.be/uvH1zB7qahI)\n",
    "- [Video Lecture \"Hybrid dialog bot\" (RU)](http://www.youtube.com/watch?v=JJCO7eWCy-M&t=331m19s)\n",
    "- [Video Lecture \"What's inside a dialog system?\" (RU)](http://www.youtube.com/watch?v=JJCO7eWCy-M&t=259m55s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix B\n",
    "### Model `gobot_dstc2_full`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's train a very smart goal-oriented bot that uses an attention mechanism over input embeddings \n",
    "\n",
    "(see https://medium.com/syncedreview/a-brief-overview-of-attention-mechanism-13c578ba9129 for more details):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initializing new config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_config = copy.deepcopy(emb_config)\n",
    "\n",
    "full_config['chainer']['pipe'] = [\n",
    "    vocab_comp_config,\n",
    "    db_comp_config,\n",
    "    embedder_comp_config\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initializing bot component config:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_with_attn_comp_config = copy.deepcopy(bot_with_embedder_comp_config)\n",
    "\n",
    "bot_with_attn_comp_config['load_path'] = 'gobot_dstc2_full/model'\n",
    "bot_with_attn_comp_config['save_path'] = 'gobot_dstc2_full/model'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding attention mechanism to bot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "attention_mechanism_config = {\n",
    "    'action_as_key': True,\n",
    "    'depth': 3,\n",
    "    'hidden_size': 32,\n",
    "    'max_num_tokens': 100,\n",
    "    'projected_align': False,\n",
    "    'type': 'cs_bahdanau'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "bot_with_attn_comp_config['network_parameters']['attention_mechanism'] = attention_mechanism_config"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding bot component to pipe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_config['chainer']['pipe'].append(bot_with_attn_comp_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:30:23.397 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-trn.jsonlist]\n",
      "2019-02-12 10:30:23.507 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-val.jsonlist]\n",
      "2019-02-12 10:30:23.851 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-tst.jsonlist]\n",
      "2019-02-12 10:30:23.942 WARNING in 'deeppavlov.core.commands.train'['train'] at line 108: \"validate_best\" and \"test_best\" parameters are deprecated. Please, use \"evaluation_targets\" list instead\n",
      "2019-02-12 10:30:23.943 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:30:23.962 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 163: [saving vocabulary to /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:30:23.963 WARNING in 'deeppavlov.core.models.serializable'['serializable'] at line 51: No load path is set for Sqlite3Database!\n",
      "2019-02-12 10:30:23.964 INFO in 'deeppavlov.core.data.sqlite_database'['sqlite_database'] at line 63: Loading database from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/resto.sqlite.\n",
      "2019-02-12 10:30:23.965 INFO in 'deeppavlov.models.embedders.fasttext_embedder'['fasttext_embedder'] at line 52: [loading fastText embeddings from `/home/vimary/ipavlov/Pilot/examples/tutorials/embeddings/dstc2_fastText_model.bin`]\n",
      "2019-02-12 10:30:24.653 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:30:24.656 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:30:25.156 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:30:25.171 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:30:25.421 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:30:25.422 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:30:25.422 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 611\n",
      "2019-02-12 10:30:25.669 INFO in 'deeppavlov.core.layers.tf_attention_mechanisms'['tf_attention_mechanisms'] at line 331: Using without projected attention alignment\n",
      "2019-02-12 10:30:27.926 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 243: [initializing `GoalOrientedBot` from scratch]\n",
      "2019-02-12 10:33:19.169 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.003\n",
      "2019-02-12 10:33:19.169 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:33:19.170 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model]\n",
      "2019-02-12 10:33:19.462 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model.json]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.003}, \"time_spent\": \"0:02:52\", \"epochs_done\": 0, \"batches_seen\": 0, \"train_examples_seen\": 0, \"impatience\": 0, \"patience_limit\": 20}}\n",
      "{\"train\": {\"eval_examples_count\": 4, \"metrics\": {\"per_item_dialog_accuracy\": 0.6452}, \"time_spent\": \"0:03:58\", \"epochs_done\": 1, \"batches_seen\": 242, \"train_examples_seen\": 967, \"loss\": 1.085083211502753, \"learning_rate\": 0.002, \"momentum\": 0.9}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:37:15.843 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 163: New best per_item_dialog_accuracy of 0.4542\n",
      "2019-02-12 10:37:15.843 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 165: Saving model\n",
      "2019-02-12 10:37:15.844 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 71: [saving model to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model]\n",
      "2019-02-12 10:37:16.87 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 708: [saving parameters to /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model.json]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.4542}, \"time_spent\": \"0:06:48\", \"epochs_done\": 1, \"batches_seen\": 242, \"train_examples_seen\": 967, \"impatience\": 0, \"patience_limit\": 20}}\n",
      "{\"train\": {\"eval_examples_count\": 4, \"metrics\": {\"per_item_dialog_accuracy\": 0.8056}, \"time_spent\": \"0:07:54\", \"epochs_done\": 2, \"batches_seen\": 484, \"train_examples_seen\": 1934, \"loss\": 0.543459503180232, \"learning_rate\": 0.002, \"momentum\": 0.9}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:41:16.343 INFO in 'deeppavlov.core.trainers.nn_trainer'['nn_trainer'] at line 169: Did not improve on the per_item_dialog_accuracy of 0.4542\n",
      "2019-02-12 10:41:16.494 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:41:16.496 WARNING in 'deeppavlov.core.models.serializable'['serializable'] at line 48: No load path is set for Sqlite3Database in 'infer' mode. Using save path instead\n",
      "2019-02-12 10:41:16.497 INFO in 'deeppavlov.core.data.sqlite_database'['sqlite_database'] at line 63: Loading database from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/resto.sqlite.\n",
      "2019-02-12 10:41:16.497 INFO in 'deeppavlov.models.embedders.fasttext_embedder'['fasttext_embedder'] at line 52: [loading fastText embeddings from `/home/vimary/ipavlov/Pilot/examples/tutorials/embeddings/dstc2_fastText_model.bin`]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"valid\": {\"eval_examples_count\": 575, \"metrics\": {\"per_item_dialog_accuracy\": 0.4534}, \"time_spent\": \"0:10:49\", \"epochs_done\": 2, \"batches_seen\": 484, \"train_examples_seen\": 1934, \"impatience\": 1, \"patience_limit\": 20}}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:41:17.262 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:41:17.264 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:41:18.135 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:41:18.148 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:41:18.410 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:41:18.411 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:41:18.412 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 611\n",
      "2019-02-12 10:41:18.631 INFO in 'deeppavlov.core.layers.tf_attention_mechanisms'['tf_attention_mechanisms'] at line 331: Using without projected attention alignment\n",
      "2019-02-12 10:41:20.630 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 240: [initializing `GoalOrientedBot` from saved]\n",
      "2019-02-12 10:41:20.631 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 714: [loading parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model.json]\n",
      "2019-02-12 10:41:20.631 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model]\n",
      "2019-02-12 10:41:20.649 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model\n",
      "2019-02-12 10:41:20.742 INFO in 'deeppavlov.core.data.vocab'['vocab'] at line 175: [loading vocabulary from /home/vimary/ipavlov/Pilot/examples/tutorials/vocabs/token.dict]\n",
      "2019-02-12 10:41:20.744 WARNING in 'deeppavlov.core.models.serializable'['serializable'] at line 48: No load path is set for Sqlite3Database in 'infer' mode. Using save path instead\n",
      "2019-02-12 10:41:20.744 INFO in 'deeppavlov.core.data.sqlite_database'['sqlite_database'] at line 63: Loading database from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/resto.sqlite.\n",
      "2019-02-12 10:41:20.746 INFO in 'deeppavlov.models.embedders.fasttext_embedder'['fasttext_embedder'] at line 52: [loading fastText embeddings from `/home/vimary/ipavlov/Pilot/examples/tutorials/embeddings/dstc2_fastText_model.bin`]\n",
      "2019-02-12 10:41:21.502 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/word.dict]\n",
      "2019-02-12 10:41:21.505 INFO in 'deeppavlov.core.data.simple_vocab'['simple_vocab'] at line 103: [loading vocabulary from /home/vimary/.deeppavlov/models/slotfill_dstc2/tag.dict]\n",
      "2019-02-12 10:41:22.499 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/.deeppavlov/models/slotfill_dstc2/model]\n",
      "2019-02-12 10:41:22.512 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/.deeppavlov/models/slotfill_dstc2/model\n",
      "2019-02-12 10:41:22.768 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 160: [loading templates from /home/vimary/ipavlov/Pilot/examples/tutorials/dstc2/dstc2-templates.txt]\n",
      "2019-02-12 10:41:22.768 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 163: 46 templates loaded\n",
      "2019-02-12 10:41:22.769 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 202: Calculated input size for `GoalOrientedBotNetwork` is 611\n",
      "2019-02-12 10:41:22.985 INFO in 'deeppavlov.core.layers.tf_attention_mechanisms'['tf_attention_mechanisms'] at line 331: Using without projected attention alignment\n",
      "2019-02-12 10:41:25.185 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 240: [initializing `GoalOrientedBot` from saved]\n",
      "2019-02-12 10:41:25.185 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 714: [loading parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model.json]\n",
      "2019-02-12 10:41:25.186 INFO in 'deeppavlov.core.models.tf_model'['tf_model'] at line 47: [loading model from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model]\n",
      "2019-02-12 10:41:25.203 INFO in 'tensorflow'['tf_logging'] at line 115: Restoring parameters from /home/vimary/ipavlov/Pilot/examples/tutorials/gobot_dstc2_full/model\n"
     ]
    }
   ],
   "source": [
    "model = train_model(full_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> Hello, welcome to the Cambridge restaurant system. You can ask for restaurants by area, price range or food type. How may I help you?\n",
      ":: Hi, i want cheap food in the north of town\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:45:49.804 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 472: Made api_call with {'pricerange': 'cheap', 'area': 'north'}, got 2 results.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: what type of food is served there?\n",
      ">> Da vinci pizzeria is a nice place in the north of town and the prices are cheap.\n",
      ":: ok, give me their phone number\n",
      ">> The phone number of da vinci pizzeria is 01223 351707.\n",
      ":: i changed my mind and i want expensive food\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:46:31.603 INFO in 'deeppavlov.models.go_bot.network'['network'] at line 472: Made api_call with {'pricerange': 'expensive', 'area': 'north'}, got 6 results.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> Saigon city is a nice place in the north of town and the prices are expensive.\n",
      ":: ok, give me their address\n",
      ">> Sure, saigon city is on 169 high street chesterton chesterton.\n",
      ":: and post code\n",
      ">> You are welcome!\n",
      ":: thanks\n",
      ">> Saigon city is a nice place in the north of town and the prices are expensive.\n",
      ":: bye\n",
      ">> Saigon city is a nice place in the north of town and the prices are expensive.\n",
      ":: exit\n"
     ]
    }
   ],
   "source": [
    "# if the cell is running, please do not run other cells in parallel -- there is a possibility of a hangup\n",
    "\n",
    "model.reset() # starting new dialog\n",
    "\n",
    "utterance = \"\"\n",
    "while utterance != 'exit':\n",
    "    print(\">> \" + model([utterance])[0])\n",
    "    utterance = input(':: ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We've trained for two epochs. For better results use > 15 epochs.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix C\n",
    "### Another way of training and infering a component"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's build response token vocabulary, but do it without using deeppavlov scripts (without `train_model` and `build_model`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "from deeppavlov.core.data.vocab import DefaultVocabulary\n",
    "from deeppavlov.dataset_readers.dstc2_reader import DSTC2DatasetReader\n",
    "from deeppavlov.dataset_iterators.dialog_iterator import DialogDatasetIterator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initializing a `DefaultVocabulary` class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_vocab = DefaultVocabulary(level='token', \n",
    "                            load_path='vocabs/y_token.dict', # path is relative to DEEPPAVLOV_ROOT/../download/ \n",
    "                            save_path='vocabs/y_token.dict',\n",
    "                            tokenizer=lambda s_batch: [s.split() for s in s_batch])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Important methods of any trained component are:\n",
    "\n",
    "   - **\\_\\_init\\_\\_(self, *args, *\\*kwargs)**\n",
    "     - intializes a class instance\n",
    "\n",
    "   - **fit(self, data, *args)** or **train_on_batch(self, batch, *args)**\n",
    "     - fits on full data or makes one training step on a batch of data\n",
    "\n",
    "   - **\\_\\_call\\_\\_(self, batch, \\*\\*kwargs)**\n",
    "     - makes prediction (or infers) for each sample in a batch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Getting batches of data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2019-02-12 10:47:05.117 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from tmp/my_download_of_dstc2/dstc2-trn.jsonlist]\n",
      "2019-02-12 10:47:05.226 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from tmp/my_download_of_dstc2/dstc2-val.jsonlist]\n",
      "2019-02-12 10:47:05.307 INFO in 'deeppavlov.dataset_readers.dstc2_reader'['dstc2_reader'] at line 113: [loading dialogs from tmp/my_download_of_dstc2/dstc2-tst.jsonlist]\n"
     ]
    }
   ],
   "source": [
    "data = DSTC2DatasetReader().read(data_path=\"tmp/my_download_of_dstc2\")\n",
    "data_samples = DialogDatasetIterator(data, seed=1443, shuffle=True).get_instances(data_type='all')\n",
    "x_list, y_list = data_samples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Building vocabulary using y batches (`y_list` contains bot responses):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_vocab.fit(y_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Infering from (using) built vocabulary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[43, 3, 26, 5, 0]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_vocab(['is', 'the', 'of', 'restaurant', 'hi'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To call a model `y_vocab(batch)` is the same as to call a \\_\\_call\\_\\_ method `y_vocab.__call__(batch)`!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_vocab(['hi']) == y_vocab.__call__(['hi']) == [0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}