Reductionist_QUS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Feature Engineering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>rustler soya less</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>pine nuts less sesame</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       0\n",
       "0      rustler soya less\n",
       "1  pine nuts less sesame"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "query = pd.read_csv(\"/Users/sks000y/Desktop/DHS/nutrition-data/testa.words.txt\", header=None)\n",
    "query.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = pd.read_csv(\"/Users/sks000y/Desktop/DHS/nutrition-data/testa.tags.txt\", header=None)\n",
    "labels.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Build vocab words (may take a while)\n",
      "- done. Kept 4504 out of 4505\n",
      "Build vocab chars\n",
      "- done. Found 49 chars\n",
      "Build vocab tags (may take a while)\n",
      "- done. Found 5 tags.\n"
     ]
    }
   ],
   "source": [
    "# Creating and segmeting the datasets\n",
    "\n",
    "from collections import Counter\n",
    "from pathlib import Path\n",
    "\n",
    "MINCOUNT = 2\n",
    "rel_path = \"/Users/sks000y/Desktop/DHS/nutrition-data/\"\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    # 1. Words\n",
    "    # Get Counter of words on all the data, filter by min count, save\n",
    "    def words(name):\n",
    "        return rel_path+'{}.words.txt'.format(name)\n",
    "\n",
    "    print('Build vocab words (may take a while)')\n",
    "    counter_words = Counter()\n",
    "    for n in ['train', 'testa', 'testb']:\n",
    "        with Path(words(n)).open() as f:\n",
    "            for line in f:\n",
    "                counter_words.update(line.strip().split())\n",
    "\n",
    "    vocab_words = {w for w, c in counter_words.items() if c >= MINCOUNT}\n",
    "\n",
    "    with Path(rel_path+'vocab.words.txt').open('w') as f:\n",
    "        for w in sorted(list(vocab_words)):\n",
    "            f.write('{}\\n'.format(w))\n",
    "    print('- done. Kept {} out of {}'.format(len(vocab_words), len(counter_words)))\n",
    "\n",
    "    # 2. Chars\n",
    "    # Get all the characters from the vocab words\n",
    "    print('Build vocab chars')\n",
    "    vocab_chars = set()\n",
    "    for w in vocab_words:\n",
    "        vocab_chars.update(w)\n",
    "\n",
    "    with Path(rel_path+'vocab.chars.txt').open('w') as f:\n",
    "        for c in sorted(list(vocab_chars)):\n",
    "            f.write('{}\\n'.format(c))\n",
    "    print('- done. Found {} chars'.format(len(vocab_chars)))\n",
    "\n",
    "    # 3. Tags\n",
    "    # Get all tags from the training set\n",
    "\n",
    "    def tags(name):\n",
    "        return rel_path+'{}.tags.txt'.format(name)\n",
    "\n",
    "    print('Build vocab tags (may take a while)')\n",
    "    vocab_tags = set()\n",
    "    with Path(tags('train')).open() as f:\n",
    "        for line in f:\n",
    "            vocab_tags.update(line.strip().split())\n",
    "\n",
    "    with Path(rel_path+'vocab.tags.txt').open('w') as f:\n",
    "        for t in sorted(list(vocab_tags)):\n",
    "            f.write('{}\\n'.format(t))\n",
    "    print('- done. Found {} tags.'.format(len(vocab_tags)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Generating Glove Embedding"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Global Vectors for Word Representation</h2>\n",
    "\n",
    "#### <ul> Pre-trained word vector: \n",
    "<li>Wikipedia 2014 + Gigaword 5 (6B tokens, 400K vocab, uncased, 50d, 100d, 200d, & 300d vectors, 822 MB download): glove.6B.zip </li>\n",
    "<li>Common Crawl (42B tokens, 1.9M vocab, uncased, 300d vectors, 1.75 GB download): glove.42B.300d.zip</li>\n",
    "<b><li>Common Crawl (840B tokens, 2.2M vocab, cased, 300d vectors, 2.03 GB download): glove.840B.300d.zip</li></b>\n",
    "<li>Twitter (2B tweets, 27B tokens, 1.2M vocab, uncased, 25d, 50d, 100d, & 200d vectors, 1.42 GB download): glove.twitter.27B.zip </li>\n",
    "    </ul>\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reading GloVe file (may take a while)\n",
      "- At line 0\n",
      "- At line 100000\n",
      "- At line 200000\n",
      "- At line 300000\n",
      "- At line 400000\n",
      "- At line 500000\n",
      "- At line 600000\n",
      "- At line 700000\n",
      "- At line 800000\n",
      "- At line 900000\n",
      "- At line 1000000\n",
      "- At line 1100000\n",
      "- At line 1200000\n",
      "- At line 1300000\n",
      "- At line 1400000\n",
      "- At line 1500000\n",
      "- At line 1600000\n",
      "- At line 1700000\n",
      "- At line 1800000\n",
      "- At line 1900000\n",
      "- At line 2000000\n",
      "- At line 2100000\n",
      "- done. Found 3795 vectors for 4504 words\n"
     ]
    }
   ],
   "source": [
    "#Creating glove\n",
    "\n",
    "\"\"\"Build an np.array from some glove file and some vocab file\n",
    "You need to download `glove.840B.300d.txt` from\n",
    "https://nlp.stanford.edu/projects/glove/ and you need to have built\n",
    "your vocabulary first (Maybe using `build_vocab.py`)\n",
    "\"\"\"\n",
    "\n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "rel_path = \"/Users/sks000y/Desktop/DHS/nutrition-data/\"\n",
    "glove_path = \"/anaconda2/envs/NER/ner/GloVe-1.2/\"\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    # Load vocab\n",
    "    with Path(rel_path+'vocab.words.txt').open() as f:\n",
    "        word_to_idx = {line.strip(): idx for idx, line in enumerate(f)}\n",
    "    size_vocab = len(word_to_idx)\n",
    "\n",
    "    # Array of zeros\n",
    "    embeddings = np.zeros((size_vocab, 300))\n",
    "\n",
    "    # Get relevant glove vectors\n",
    "    found = 0\n",
    "    print('Reading GloVe file (may take a while)')\n",
    "    with Path(glove_path+'glove.840B.300d.txt').open() as f:\n",
    "        for line_idx, line in enumerate(f):\n",
    "            if line_idx % 100000 == 0:\n",
    "                print('- At line {}'.format(line_idx))\n",
    "            line = line.strip().split()\n",
    "            if len(line) != 300 + 1:\n",
    "                continue\n",
    "            word = line[0]\n",
    "            embedding = line[1:]\n",
    "            if word in word_to_idx:\n",
    "                found += 1\n",
    "                word_idx = word_to_idx[word]\n",
    "                embeddings[word_idx] = embedding\n",
    "    print('- done. Found {} vectors for {} words'.format(found, size_vocab))\n",
    "\n",
    "    # Save np.array to file\n",
    "    #np.savez_compressed(re_path+'glove.npz', embeddings=embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Save np.array to file\n",
    "np.savez_compressed(rel_path+'glove.npz', embeddings=embeddings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Modelling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import functools\n",
    "import json\n",
    "import logging\n",
    "from pathlib import Path\n",
    "import sys\n",
    "import io\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow import metrics\n",
    "\n",
    "DATADIR = '/Users/sks000y/Desktop/DHS/nutrition-data/'\n",
    "\n",
    "# Logging\n",
    "Path('results3').mkdir(exist_ok=True)\n",
    "tf.logging.set_verbosity(logging.INFO)\n",
    "handlers = [\n",
    "    logging.FileHandler('results3/main.log'),\n",
    "    logging.StreamHandler(sys.stdout)\n",
    "]\n",
    "logging.getLogger('tensorflow').handlers = handlers\n",
    "\n",
    "import unicodedata\n",
    "\n",
    "def strip_accents(text):\n",
    "    \"\"\"\n",
    "    Strip accents from input String.\n",
    "\n",
    "    :param text: The input string.\n",
    "    :type text: String.\n",
    "\n",
    "    :returns: The processed String.\n",
    "    :rtype: String.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        text = unicode(text, 'utf-8')\n",
    "    except (TypeError, NameError): # unicode is a default on python 3 \n",
    "        pass\n",
    "    text = unicodedata.normalize('NFD', text)\n",
    "    text = text.encode('ascii', 'ignore')\n",
    "    text = text.decode(\"utf-8\")\n",
    "    return str(text)\n",
    "\n",
    "def parse_fn(line_words, line_tags):\n",
    "    # Encode in Bytes for TF\n",
    "    words = [w.encode() for w in line_words.strip().split()]\n",
    "    tags = [t.encode() for t in line_tags.strip().split()]\n",
    "    assert len(words) == len(tags), \"Words and tags lengths don't match\"\n",
    "\n",
    "    # Chars\n",
    "    chars = [[c.encode() for c in w] for w in line_words.strip().split()]\n",
    "    lengths = [len(c) for c in chars]\n",
    "    max_len = max(lengths)\n",
    "    chars = [c + [b'<pad>'] * (max_len - l) for c, l in zip(chars, lengths)]\n",
    "    return ((words, len(words)), (chars, lengths)), tags\n",
    "\n",
    "\n",
    "def generator_fn(words, tags):\n",
    "    with Path(words).open('r') as f_words, Path(tags).open('r') as f_tags:\n",
    "        for line_words, line_tags in zip(f_words, f_tags):\n",
    "            yield parse_fn(strip_accents(line_words), strip_accents(line_tags))\n",
    "\n",
    "\n",
    "def input_fn(words, tags, params=None, shuffle_and_repeat=False):\n",
    "    params = params if params is not None else {}\n",
    "    shapes = ((([None], ()),               # (words, nwords)\n",
    "               ([None, None], [None])),    # (chars, nchars)\n",
    "              [None])                      # tags\n",
    "    types = (((tf.string, tf.int32),\n",
    "              (tf.string, tf.int32)),\n",
    "             tf.string)\n",
    "    defaults = ((('<pad>', 0),\n",
    "                 ('<pad>', 0)),\n",
    "                'O')\n",
    "    dataset = tf.data.Dataset.from_generator(\n",
    "        functools.partial(generator_fn, words, tags),\n",
    "        output_shapes=shapes, output_types=types)\n",
    "\n",
    "    if shuffle_and_repeat:\n",
    "        dataset = dataset.shuffle(params['buffer']).repeat(params['epochs'])\n",
    "\n",
    "    dataset = (dataset\n",
    "               .padded_batch(params.get('batch_size', 2500), shapes, defaults)\n",
    "               .prefetch(1))\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<h2>Tensorflow Estimator API </h2><h3> using custom Estimators and Tensorflow tf.data have been used for writing the code of all the training, modeling and evaluation.<br><br>\n",
    "    \n",
    "<li>Custom Estimator in Tensorflow has tf.estimator.Estimator class which wraps a model which is specified by a model_fnand tf.estimator.train_and_evaluate utility function which trains, evaluates, and (optionally) exports the model by using the given estimator.</li></h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def model_fn(features, labels, mode, params):\n",
    "    # Read vocabs and inputs\n",
    "    \n",
    "    if isinstance(features, dict):\n",
    "        features = ((features['words'], features['nwords']),\n",
    "                    (features['chars'], features['nchars']))\n",
    "    # Read vocabs and inputs\n",
    "    dropout = params['dropout']\n",
    "    (words, nwords), (chars, nchars) = features\n",
    "    \n",
    "    #Check whether training mode so as to make dropout activate/deactivate\n",
    "    training = (mode == tf.estimator.ModeKeys.TRAIN)\n",
    "    \n",
    "    \n",
    "    vocab_words = tf.contrib.lookup.index_table_from_file(\n",
    "        params['words'], num_oov_buckets=params['num_oov_buckets'])\n",
    "    vocab_chars = tf.contrib.lookup.index_table_from_file(\n",
    "        params['chars'], num_oov_buckets=params['num_oov_buckets'])\n",
    "    \n",
    "    with Path(params['tags']).open() as f:\n",
    "        indices = [idx for idx, tag in enumerate(f) if tag.strip() != 'O']\n",
    "        num_tags = len(indices) + 1\n",
    "    with Path(params['chars']).open() as f:\n",
    "        num_chars = sum(1 for _ in f) + params['num_oov_buckets']\n",
    "\n",
    "    # Char Embeddings\n",
    "    \n",
    "    #For each sentence and words, we have a list of characters\n",
    "    #We find the index of character present in the dictionary of all characters\n",
    "    char_ids = vocab_chars.lookup(chars)  #[sentence, words, chars] \n",
    "    \n",
    "    #Initialize a variable [total_number_of_chars, dimension of char_embedding=100] \n",
    "    #storing the initial embedding of all characters with some random floating point numbers\n",
    "    variable = tf.get_variable(\n",
    "        'chars_embeddings', [num_chars, params['dim_chars']], tf.float32)\n",
    "    \n",
    "    #Lookup the embeddings of the chars in char_ids \n",
    "    char_embeddings = tf.nn.embedding_lookup(variable, char_ids) #[sentence, word, chars, char_dim=100]\n",
    "    \n",
    "    char_embeddings = tf.layers.dropout(char_embeddings, rate=dropout,\n",
    "                                        training=training)\n",
    "\n",
    "    # Char LSTM\n",
    "    \n",
    "    #[max_length of sentences in batch]\n",
    "    dim_words = tf.shape(char_embeddings)[1]\n",
    "    #[max_length of words in all the sentences]\n",
    "    dim_chars = tf.shape(char_embeddings)[2]\n",
    "    \n",
    "    #[sentence*max_words_in_sentence ,max_chars_in_all_words, char_dim=100]\n",
    "    flat = tf.reshape(char_embeddings, [-1, dim_chars, params['dim_chars']]) \n",
    "    #making time major from batch major as required by tf.contrib.rnnt = \n",
    "    t = tf.transpose(flat, perm=[1, 0, 2])\n",
    "    \n",
    "    #Initializing LSTM each having 25 units\n",
    "    lstm_cell_fw = tf.contrib.rnn.LSTMBlockFusedCell(params['char_lstm_size'])\n",
    "    lstm_cell_bw = tf.contrib.rnn.LSTMBlockFusedCell(params['char_lstm_size'])\n",
    "    \n",
    "    #Creating backward dir LSTM\n",
    "    lstm_cell_bw = tf.contrib.rnn.TimeReversedFusedRNN(lstm_cell_bw)\n",
    "    \n",
    "    #output having dim [max_chars_in_all_words, sentence*max_words_in_sentence, char_embd_size=25]\n",
    "    #Here time_steps i.e.[sequence_length] = number of chars in each words\n",
    "    _, (_, output_fw) = lstm_cell_fw(t, dtype=tf.float32,\n",
    "                                     sequence_length=tf.reshape(nchars, [-1]))\n",
    "    \n",
    "    #Reverse Bi-LSTM output\n",
    "    _, (_, output_bw) = lstm_cell_bw(t, dtype=tf.float32,\n",
    "                                     sequence_length=tf.reshape(nchars, [-1]))\n",
    "    \n",
    "    #[max_chars_in_all_words, sentence*max_words_in_sentence, char_embd_size=25+25=50]\n",
    "    output = tf.concat([output_fw, output_bw], axis=-1)\n",
    "    \n",
    "    #Reshape to [num_of_sentences, max_num_of_words, 50]\n",
    "    char_embeddings = tf.reshape(output, [-1, dim_words, 50])\n",
    "    \n",
    "    \n",
    "\n",
    "    # Word Embeddings\n",
    "    \n",
    "    #For each sentence, we have a list of words\n",
    "    #We find the index of words present in the dictionary of all words\n",
    "    word_ids = vocab_words.lookup(words) #[sentence, words]\n",
    "    \n",
    "    #Getting the glove embeddings of all the words\n",
    "    glove = np.load(params['glove'])['embeddings']  # np.array\n",
    "    \n",
    "    #Appending an extra embeddings to return if some word is not found\n",
    "    variable = np.vstack([glove, [[0.] * params['dim']]])\n",
    "    variable = tf.Variable(variable, dtype=tf.float32, trainable=False)\n",
    "    #Look up the word embeddings in the dictionary we created as non-trainable\n",
    "    word_embeddings = tf.nn.embedding_lookup(variable, word_ids, validate_indices=False)\n",
    "\n",
    "    # Concatenate Word and Char Embeddings\n",
    "    embeddings = tf.concat([word_embeddings, char_embeddings], axis=-1)\n",
    "    embeddings = tf.layers.dropout(embeddings, rate=dropout, training=training)\n",
    "\n",
    "    \n",
    "    \n",
    "    # LSTM\n",
    "    \n",
    "    #Time major, input shape= [sentences, words, 350]\n",
    "    t = tf.transpose(embeddings, perm=[1, 0, 2])  # Need time-major\n",
    "    #Forward and Backward lstm each of 100 units\n",
    "    lstm_cell_fw = tf.contrib.rnn.LSTMBlockFusedCell(params['lstm_size'])\n",
    "    lstm_cell_bw = tf.contrib.rnn.LSTMBlockFusedCell(params['lstm_size'])\n",
    "    lstm_cell_bw = tf.contrib.rnn.TimeReversedFusedRNN(lstm_cell_bw)\n",
    "    \n",
    "    # time steps i.e. [sequence_length] having number of words in each sentence\n",
    "    output_fw, _ = lstm_cell_fw(t, dtype=tf.float32, sequence_length=nwords) #[sentence, words, 100]\n",
    "    output_bw, _ = lstm_cell_bw(t, dtype=tf.float32, sequence_length=nwords) #[sentence, words, 100]\n",
    "    \n",
    "    # Concatenate the both forward and backword encoding \n",
    "    output = tf.concat([output_fw, output_bw], axis=-1) #[sentence, words, 100+100=200]\n",
    "    output = tf.transpose(output, perm=[1, 0, 2]) #transponse to original shape\n",
    "    output = tf.layers.dropout(output, rate=dropout, training=training)\n",
    "\n",
    "    #Create a dense layer to reduce the output to num of tags\n",
    "    logits = tf.layers.dense(output, num_tags) # [sentence, word, num_of_tag=6]\n",
    "    \n",
    "    #CRF\n",
    "    \n",
    "    #Create a variable and initialize as a transition score from one tags to another tags\n",
    "    #in determining the score of a particular combination of tags\n",
    "    crf_params = tf.get_variable(\"crf\", [num_tags, num_tags], dtype=tf.float32)\n",
    "    \n",
    "    # determining the tags for each sentence # [sentence, no_of_tags]\n",
    "    pred_ids, _ = tf.contrib.crf.crf_decode(logits, crf_params, nwords)\n",
    "\n",
    "    if mode == tf.estimator.ModeKeys.PREDICT:\n",
    "        # Predictions\n",
    "        reverse_vocab_tags = tf.contrib.lookup.index_to_string_table_from_file(\n",
    "            params['tags'])\n",
    "        pred_strings = reverse_vocab_tags.lookup(tf.to_int64(pred_ids))\n",
    "        predictions = {\n",
    "            'pred_ids': pred_ids,\n",
    "            'tags': pred_strings\n",
    "        }\n",
    "        return tf.estimator.EstimatorSpec(mode, predictions=predictions)\n",
    "    else:\n",
    "        # Loss\n",
    "        vocab_tags = tf.contrib.lookup.index_table_from_file(params['tags'],default_value=0)\n",
    "        tags = vocab_tags.lookup(labels)\n",
    "        log_likelihood, _ = tf.contrib.crf.crf_log_likelihood(\n",
    "            logits, tags, nwords, crf_params)\n",
    "        loss = tf.reduce_mean(-log_likelihood)\n",
    "\n",
    "        # Metrics\n",
    "        weights = tf.sequence_mask(nwords)\n",
    "        metrics = {\n",
    "            'acc': tf.metrics.accuracy(tags, pred_ids, weights)\n",
    "        }\n",
    "        for metric_name, op in metrics.items():\n",
    "            tf.summary.scalar(metric_name, op[1])\n",
    "\n",
    "        if mode == tf.estimator.ModeKeys.EVAL:\n",
    "            return tf.estimator.EstimatorSpec(\n",
    "                mode, loss=loss, eval_metric_ops=metrics)\n",
    "\n",
    "        elif mode == tf.estimator.ModeKeys.TRAIN:\n",
    "            train_op = tf.train.AdamOptimizer().minimize(\n",
    "                loss, global_step=tf.train.get_or_create_global_step())\n",
    "            return tf.estimator.EstimatorSpec(\n",
    "                mode, loss=loss, train_op=train_op)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using config: {'_model_dir': '/Users/sks000y/Desktop/DHS/nutrition-data/results3/model', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 120, '_session_config': allow_soft_placement: true\n",
      "graph_options {\n",
      "  rewrite_options {\n",
      "    meta_optimizer_iterations: ONE\n",
      "  }\n",
      "}\n",
      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x14a4543c8>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:56.570362 4614768064 estimator.py:209] Using config: {'_model_dir': '/Users/sks000y/Desktop/DHS/nutrition-data/results3/model', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 120, '_session_config': allow_soft_placement: true\n",
      "graph_options {\n",
      "  rewrite_options {\n",
      "    meta_optimizer_iterations: ONE\n",
      "  }\n",
      "}\n",
      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x14a4543c8>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not using Distribute Coordinator.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:56.572524 4614768064 estimator_training.py:186] Not using Distribute Coordinator.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running training and evaluation locally (non-distributed).\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:56.573843 4614768064 training.py:612] Running training and evaluation locally (non-distributed).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 120.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:56.575311 4614768064 training.py:700] Start train and evaluate loop. The evaluate will happen after every checkpoint. Checkpoint frequency is determined based on RunConfig arguments: save_checkpoints_steps None or save_checkpoints_secs 120.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:56.626874 4614768064 estimator.py:1145] Calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:58.744024 4614768064 estimator.py:1147] Done calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Create CheckpointSaverHook.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:58.746921 4614768064 basic_session_run_hooks.py:541] Create CheckpointSaverHook.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Graph was finalized.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:58.880584 4614768064 monitored_session.py:240] Graph was finalized.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-862\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:58.884063 4614768064 saver.py:1280] Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-862\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:59.072805 4614768064 session_manager.py:500] Running local_init_op.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:27:59.117530 4614768064 session_manager.py:502] Done running local_init_op.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving checkpoints for 862 into /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:28:01.216736 4614768064 basic_session_run_hooks.py:606] Saving checkpoints for 862 into /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = 0.017627865, step = 863\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:28:04.919068 4614768064 basic_session_run_hooks.py:262] loss = 0.017627865, step = 863\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global_step/sec: 2.55166\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:28:44.108973 4614768064 basic_session_run_hooks.py:692] global_step/sec: 2.55166\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = 0.019387666, step = 963 (39.191 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:28:44.110518 4614768064 basic_session_run_hooks.py:260] loss = 0.019387666, step = 963 (39.191 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global_step/sec: 2.44516\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:25.006165 4614768064 basic_session_run_hooks.py:692] global_step/sec: 2.44516\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss = 0.006845953, step = 1063 (40.897 sec)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:25.007909 4614768064 basic_session_run_hooks.py:260] loss = 0.006845953, step = 1063 (40.897 sec)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving checkpoints for 1102 into /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:42.429743 4614768064 basic_session_run_hooks.py:606] Saving checkpoints for 1102 into /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:42.781968 4614768064 estimator.py:1145] Calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:43.720898 4614768064 estimator.py:1147] Done calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting evaluation at 2019-10-07T13:29:43Z\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:43.748197 4614768064 evaluation.py:255] Starting evaluation at 2019-10-07T13:29:43Z\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Graph was finalized.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:44.042522 4614768064 monitored_session.py:240] Graph was finalized.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-1102\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:44.046168 4614768064 saver.py:1280] Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-1102\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:44.148252 4614768064 session_manager.py:500] Running local_init_op.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:44.180175 4614768064 session_manager.py:502] Done running local_init_op.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation [10/100]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:46.417123 4614768064 evaluation.py:167] Evaluation [10/100]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation [20/100]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:48.296336 4614768064 evaluation.py:167] Evaluation [20/100]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation [30/100]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:50.119359 4614768064 evaluation.py:167] Evaluation [30/100]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation [40/100]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:51.897351 4614768064 evaluation.py:167] Evaluation [40/100]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished evaluation at 2019-10-07-13:29:51\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:51.952627 4614768064 evaluation.py:275] Finished evaluation at 2019-10-07-13:29:51\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving dict for global step 1102: acc = 0.99987864, global_step = 1102, loss = 0.0018811794\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:51.954382 4614768064 estimator.py:2039] Saving dict for global step 1102: acc = 0.99987864, global_step = 1102, loss = 0.0018811794\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving 'checkpoint_path' summary for global step 1102: /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-1102\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:51.956799 4614768064 estimator.py:2099] Saving 'checkpoint_path' summary for global step 1102: /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-1102\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss for final step: 0.013478433.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:29:51.993923 4614768064 estimator.py:368] Loss for final step: 0.013478433.\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    # Params\n",
    "    params = {\n",
    "        'dim': 300,\n",
    "        'dim_chars': 100,\n",
    "        'dropout': 0.5,\n",
    "        'num_oov_buckets': 1,\n",
    "        'epochs': 1,\n",
    "        'batch_size': 500,\n",
    "        'buffer': 15000,\n",
    "        'char_lstm_size': 25,\n",
    "        'lstm_size': 100,\n",
    "        'words': str(Path(DATADIR, 'vocab.words.txt')),\n",
    "        'chars': str(Path(DATADIR, 'vocab.chars.txt')),\n",
    "        'tags': str(Path(DATADIR, 'vocab.tags.txt')),\n",
    "        'glove': str(Path(DATADIR, 'glove.npz'))\n",
    "    }\n",
    "    with io.open(\"results3/params.json\",'w',encoding=\"utf-8\") as outfile:\n",
    "        outfile.write(json.dumps(params, ensure_ascii=False))\n",
    "\n",
    "    def fwords(name):\n",
    "        return str(Path(DATADIR, '{}.words.txt'.format(name)))\n",
    "\n",
    "    def ftags(name):\n",
    "        return str(Path(DATADIR, '{}.tags.txt'.format(name)))\n",
    "\n",
    "    # Estimator, train and evaluate\n",
    "    train_inpf = functools.partial(input_fn, fwords('train'), ftags('train'),\n",
    "                                   params, shuffle_and_repeat=True)\n",
    "    eval_inpf = functools.partial(input_fn, fwords('testa'), ftags('testa'))\n",
    "\n",
    "    cfg = tf.estimator.RunConfig(save_checkpoints_secs=120)\n",
    "    #ws = tf.estimator.WarmStartSettings(ckpt_to_initialize_from='/content/results3/model')\n",
    "    estimator = tf.estimator.Estimator(model_fn, DATADIR+'results3/model', cfg, params)\n",
    "    Path(estimator.eval_dir()).mkdir(parents=True, exist_ok=True)\n",
    "   # hook = tf.contrib.estimator.stop_if_no_increase_hook(\n",
    "   #     estimator, 'acc', 500, min_steps=2000, run_every_secs=120)\n",
    "    train_spec = tf.estimator.TrainSpec(input_fn=train_inpf)\n",
    "    eval_spec = tf.estimator.EvalSpec(input_fn=eval_inpf, throttle_secs=120)\n",
    "    tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)\n"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def parse_fn_loc(line_words, line_tags):\n",
    "   # Encode in Bytes for TF\n",
    "    words = [w.encode() for w in line_words.strip().split()]\n",
    "    tags = [t.encode() for t in line_tags.strip().split()]\n",
    "    assert len(words) == len(tags), \"Words and tags lengths don't match\"\n",
    "\n",
    "    # Chars\n",
    "    chars = [[c.encode() for c in w] for w in line_words.strip().split()]\n",
    "    lengths = [len(c) for c in chars]\n",
    "    max_len = max(lengths)\n",
    "    chars = [c + [b'<pad>'] * (max_len - l) for c, l in zip(chars, lengths)]\n",
    "    yield ((words, len(words)), (chars, lengths)), tags    \n",
    "\n",
    "def input_fn_loc(words, tags, params=None):\n",
    "    params = params if params is not None else {}\n",
    "    shapes = ((([None], ()),               # (words, nwords)\n",
    "               ([None, None], [None])),    # (chars, nchars)\n",
    "              [None])                      # tags\n",
    "    types = (((tf.string, tf.int32),\n",
    "              (tf.string, tf.int32)),\n",
    "             tf.string)\n",
    "    defaults = ((('<pad>', 0),\n",
    "                 ('<pad>', 0)),\n",
    "                'O')\n",
    "    dataset = tf.data.Dataset.from_generator(\n",
    "        functools.partial(parse_fn_loc, words, tags),\n",
    "        output_shapes=shapes, output_types=types)\n",
    "\n",
    "    dataset = (dataset\n",
    "               .padded_batch(params.get('batch_size', 2500), shapes, defaults)\n",
    "               .prefetch(1))\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import functools\n",
    "test_inpf = functools.partial(input_fn_loc, \"gluten free bread\", \"O O O\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using default config.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:42:29.540175 4614768064 estimator.py:1790] Using default config.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using config: {'_model_dir': '/Users/sks000y/Desktop/DHS/nutrition-data/results3/model', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
      "graph_options {\n",
      "  rewrite_options {\n",
      "    meta_optimizer_iterations: ONE\n",
      "  }\n",
      "}\n",
      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x13f55bf28>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:42:29.542147 4614768064 estimator.py:209] Using config: {'_model_dir': '/Users/sks000y/Desktop/DHS/nutrition-data/results3/model', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true\n",
      "graph_options {\n",
      "  rewrite_options {\n",
      "    meta_optimizer_iterations: ONE\n",
      "  }\n",
      "}\n",
      ", '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_device_fn': None, '_protocol': None, '_eval_distribute': None, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x13f55bf28>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}\n"
     ]
    }
   ],
   "source": [
    "ws=tf.estimator.WarmStartSettings(ckpt_to_initialize_from=DATADIR+'results3/model')\n",
    "estimator = tf.estimator.Estimator(model_fn, DATADIR+'results3/model', None, params,warm_start_from=ws)\n",
    "preds_gen = estimator.predict(test_inpf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:42:31.671561 4614768064 estimator.py:1145] Calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:42:32.235394 4614768064 estimator.py:1147] Done calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Graph was finalized.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:42:32.312917 4614768064 monitored_session.py:240] Graph was finalized.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-1102\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:42:32.315630 4614768064 saver.py:1280] Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-1102\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:42:32.391998 4614768064 session_manager.py:500] Running local_init_op.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done running local_init_op.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:42:32.411287 4614768064 session_manager.py:502] Done running local_init_op.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'pred_ids': array([4, 1, 3], dtype=int32),\n",
       " 'tags': array([b'NV-S', b'AD-S', b'BQ-S'], dtype=object)}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(preds_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Make it to Production"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def serving_input_receiver_fn():\n",
    "    \"\"\"Serving input_fn that builds features from placeholders\n",
    "    Returns\n",
    "    -------\n",
    "    tf.estimator.export.ServingInputReceiver\n",
    "    \"\"\"\n",
    "    words = tf.placeholder(dtype=tf.string, shape=[None, None], name='words')\n",
    "    nwords = tf.placeholder(dtype=tf.int32, shape=[None], name='nwords')\n",
    "    chars = tf.placeholder(dtype=tf.string, shape=[None, None, None],\n",
    "                           name='chars')\n",
    "    nchars = tf.placeholder(dtype=tf.int32, shape=[None, None],\n",
    "                            name='nchars')\n",
    "    receiver_tensors = {'words': words, 'nwords': nwords,\n",
    "                        'chars': chars, 'nchars': nchars}\n",
    "    features = {'words': words, 'nwords': nwords,\n",
    "                'chars': chars, 'nchars': nchars}\n",
    "    return tf.estimator.export.ServingInputReceiver(features, receiver_tensors)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:02.590480 4614768064 estimator.py:1145] Calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done calling model_fn.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.120929 4614768064 estimator.py:1147] Done calling model_fn.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From /anaconda2/envs/oop_python3/lib/python3.7/site-packages/tensorflow/python/saved_model/signature_def_utils_impl.py:201: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W1007 13:32:03.122552 4614768064 deprecation.py:323] From /anaconda2/envs/oop_python3/lib/python3.7/site-packages/tensorflow/python/saved_model/signature_def_utils_impl.py:201: build_tensor_info (from tensorflow.python.saved_model.utils_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This function will only be available through the v1 compatibility library as tf.compat.v1.saved_model.utils.build_tensor_info or tf.compat.v1.saved_model.build_tensor_info.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Signatures INCLUDED in export for Classify: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.124125 4614768064 export_utils.py:170] Signatures INCLUDED in export for Classify: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Signatures INCLUDED in export for Regress: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.125573 4614768064 export_utils.py:170] Signatures INCLUDED in export for Regress: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Signatures INCLUDED in export for Predict: ['serving_default']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.126736 4614768064 export_utils.py:170] Signatures INCLUDED in export for Predict: ['serving_default']\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Signatures INCLUDED in export for Train: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.128243 4614768064 export_utils.py:170] Signatures INCLUDED in export for Train: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Signatures INCLUDED in export for Eval: None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.129336 4614768064 export_utils.py:170] Signatures INCLUDED in export for Eval: None\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-1102\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.156321 4614768064 saver.py:1280] Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/results3/model/model.ckpt-1102\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Assets added to graph.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.198863 4614768064 builder_impl.py:661] Assets added to graph.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Assets written to: /Users/sks000y/Desktop/DHS/nutrition-data/tf-serving-ner/model/temp-b'1570435322'/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.201336 4614768064 builder_impl.py:770] Assets written to: /Users/sks000y/Desktop/DHS/nutrition-data/tf-serving-ner/model/temp-b'1570435322'/assets\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SavedModel written to: /Users/sks000y/Desktop/DHS/nutrition-data/tf-serving-ner/model/temp-b'1570435322'/saved_model.pb\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:32:03.387214 4614768064 builder_impl.py:421] SavedModel written to: /Users/sks000y/Desktop/DHS/nutrition-data/tf-serving-ner/model/temp-b'1570435322'/saved_model.pb\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "b'/Users/sks000y/Desktop/DHS/nutrition-data/tf-serving-ner/model/1570435322'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estimator.export_savedmodel(DATADIR+'tf-serving-ner/model', serving_input_receiver_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/tf-serving-ner/model/1570435322/variables/variables\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I1007 13:43:00.437886 4614768064 saver.py:1280] Restoring parameters from /Users/sks000y/Desktop/DHS/nutrition-data/tf-serving-ner/model/1570435322/variables/variables\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'pred_ids': array([[4, 1, 3]], dtype=int32), 'tags': array([[b'NV-S', b'AD-S', b'BQ-S']], dtype=object)}\n"
     ]
    }
   ],
   "source": [
    "def parse_fn_pred(line):\n",
    "    # Encode in Bytes for TF\n",
    "    words = [w.encode() for w in line.strip().split()]\n",
    "\n",
    "    # Chars\n",
    "    chars = [[c.encode() for c in w] for w in line.strip().split()]\n",
    "    lengths = [len(c) for c in chars]\n",
    "    max_len = max(lengths)\n",
    "    chars = [c + [b'<pad>'] * (max_len - l) for c, l in zip(chars, lengths)]\n",
    "\n",
    "    return {'words': [words], 'nwords': [len(words)],\n",
    "            'chars': [chars], 'nchars': [lengths]}\n",
    "\n",
    "from tensorflow.contrib import predictor\n",
    "predict_fn = predictor.from_saved_model('/Users/sks000y/Desktop/DHS/nutrition-data/tf-serving-ner/model/1570435322')\n",
    "predictions = predict_fn(parse_fn_pred(\"gluten free bread\"))\n",
    "print(predictions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensorflow Serving\n",
    "\n",
    "## TensorFlow Serving is a flexible, high-performance serving system for machine learning models, designed for production environments.\n",
    "\n",
    "### Checkpoints capture the exact value of all parameters (tf.Variable objects) used by a model. Checkpoints do not contain any description of the computation defined by the model and thus are typically only useful when source code that will use the saved parameter values is available."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Download the TensorFlow Serving Docker image\n",
    "docker pull tensorflow/serving\n",
    "\n",
    "### Start TensorFlow Serving container and open the REST API port\n",
    "docker run -t --rm -p 8501:8501 \\\n",
    "    -v \"dir/model_name:/models/model_name\" \\\n",
    "    -e MODEL_NAME=model_name \\\n",
    "    tensorflow/serving &\n",
    "\n",
    "### Query the model using the predict API\n",
    "curl -d '{\"instances\": [1.0, 2.0, 5.0]}' \\\n",
    "    -X POST http://localhost:8501/v1/models/model_name:predict\n",
    "\n",
    "### Returns => { \"predictions\": [2.5, 3.0, 4.5] }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python (oop_python3)",
   "language": "python",
   "name": "oop_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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}