deep_learning/time_series_sequences/Seq2Seq_Bidirectional_Attention_tf-1.0.0.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensorflow version: 1.0.0\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "import tensorflow as tf\n",
    "import tensorflow.contrib.seq2seq as seq2seq\n",
    "from tensorflow.contrib.rnn import LSTMCell, GRUCell, LSTMStateTuple\n",
    "from tensorflow.contrib.layers import safe_embedding_lookup_sparse as embedding_lookup_unique\n",
    "\n",
    "print(\"Tensorflow version: {}\".format(tf.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helper Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def batch(inputs, max_sequence_length=None):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        inputs:\n",
    "            list of sentences (integer lists)\n",
    "        max_sequence_length:\n",
    "            integer specifying how large should `max_time` dimension be.\n",
    "            If None, maximum sequence length would be used\n",
    "    \n",
    "    Outputs:\n",
    "        inputs_time_major:\n",
    "            input sentences transformed into time-major matrix \n",
    "            (shape [max_time, batch_size]) padded with 0s\n",
    "        sequence_lengths:\n",
    "            batch-sized list of integers specifying amount of active \n",
    "            time steps in each input sequence\n",
    "            \n",
    "    Example:\n",
    "    batch([[3,7,6],[8,6],[5,7,4,8]])\n",
    "    array([[3, 8, 5],\n",
    "           [7, 6, 7],\n",
    "           [6, 0, 4],\n",
    "           [0, 0, 8]], dtype=int32)\n",
    "    \"\"\"\n",
    "    \n",
    "    sequence_length = [len(seq) for seq in inputs]\n",
    "    batch_size = len(inputs)\n",
    "    \n",
    "    if max_sequence_length is None:\n",
    "        max_sequence_length = max(sequence_length)\n",
    "    \n",
    "    # [batch_size, time_series]\n",
    "    inputs_batch_major = np.zeros(shape=[batch_size, max_sequence_length], dtype=np.int32)\n",
    "    \n",
    "    for i, seq in enumerate(inputs):\n",
    "        for j, element in enumerate(seq):\n",
    "            inputs_batch_major[i, j] = element\n",
    "    \n",
    "    # switch to time_major as [time_series, batch_size]\n",
    "    inputs_batch_major = inputs_batch_major.swapaxes(0, 1)\n",
    "    \n",
    "    return inputs_batch_major, sequence_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def random_sequences(length_from, length_to, vocab_lower, vocab_upper, batch_size):\n",
    "    \"\"\" \n",
    "    Description:\n",
    "        Generates batches of random integer sequences,\n",
    "        sequence length in [length_from, length_to],\n",
    "        vocabulary in [vocab_lower, vocab_upper]\n",
    "    Example:\n",
    "    data = random_sequence(length_from=3, length_to=8, vocab_lower=3, vocab_upper=10, batch_size=10)\n",
    "    next(data)\n",
    "    \"\"\"\n",
    "    assert length_from <= length_to, \"length_from > length_to is error.\"\n",
    "    \n",
    "    def random_length():\n",
    "        if length_from == length_to:\n",
    "            return length_from\n",
    "        return np.random.randint(length_from, length_to + 1)\n",
    "    \n",
    "    while True:\n",
    "        yield [np.random.randint(low=vocab_lower, high=vocab_upper, size=random_length()).tolist() \n",
    "               for _ in range(batch_size)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class helpers():\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "helpers.batch = batch\n",
    "helpers.random_sequences = random_sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seq2Seq Model\n",
    "\n",
    "In designing Seq2Seq graph, the train and inference processes are separated. \n",
    "* Therefore we need a property named `_init_decoder_train_connectors` to define the decoder's behavior during training. \n",
    "* Besides, in `_init_decoder` property we have to define two types of different `dynamic_rnn_decoder` running for train and inference separatedly.\n",
    "* In the final, we also need `make_train_inputs` and `make_inference_inputs` to feed the data into the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Seq2SeqModel():\n",
    "    \n",
    "    PAD = 0\n",
    "    EOS = 1\n",
    "    \n",
    "    def __init__(self, encoder_cell, decoder_cell, \\\n",
    "                 vocab_size, embedding_size, \\\n",
    "                 bidirectional=True, attention=False, debug=False):\n",
    "        \n",
    "        self.encoder_cell = encoder_cell\n",
    "        self.decoder_cell = decoder_cell\n",
    "        self.vocab_size = vocab_size\n",
    "        self.embedding_size = embedding_size\n",
    "        self.bidirectional = bidirectional\n",
    "        self.attention = attention\n",
    "        self.debug = debug\n",
    "        \n",
    "        # contruct the rnn definition graph\n",
    "        self._make_graph()\n",
    "           \n",
    "    def _make_graph(self):\n",
    "        if self.debug:\n",
    "            self._init_debug_inputs()\n",
    "        else:\n",
    "            self._init_placeholders()\n",
    "            \n",
    "        self._init_decoder_train_connectors()\n",
    "        self._init_embeddings()\n",
    "        \n",
    "        if self.bidirectional:\n",
    "            self._init_bidirectional_encoder()\n",
    "        else:\n",
    "            self._init_simple_encoder()\n",
    "        \n",
    "        self._init_decoder()\n",
    "        \n",
    "        self._init_optimizer()\n",
    "            \n",
    "    def _init_debug_inputs(self):\n",
    "        \"\"\"\n",
    "        Data is time major. Here we create simple encoder and decoder data. They are the same.\n",
    "        \"\"\"\n",
    "        x = [[5,6,7],\n",
    "             [7,6,0],\n",
    "             [0,7,0]]\n",
    "        xlen = [2,3,1]\n",
    "        \n",
    "        self.encoder_inputs = tf.constant(x, dtype=tf.int32, name=\"encoder_inputs\")\n",
    "        self.encoder_inputs_length = tf.constant(xlen, dtype=tf.int32, name=\"encoder_inputs_length\")\n",
    "        \n",
    "        self.decoder_targets = tf.constant(x, dtype=tf.int32, name=\"deocder_targets\")\n",
    "        self.decoder_targets_length = tf.constant(xlen, dtype=tf.int32, name=\"decoder_targets_length\")\n",
    "    \n",
    "    def _init_placeholders(self):\n",
    "        \"\"\"Data is time major.\"\"\"\n",
    "        self.encoder_inputs = tf.placeholder(shape=(None, None), dtype=tf.int32, name=\"encoder_inputs\")\n",
    "        self.encoder_inputs_length = tf.placeholder(shape=(None,), dtype=tf.int32, name=\"encoder_inputs_length\")\n",
    "        \n",
    "        self.decoder_targets = tf.placeholder(shape=(None, None), dtype=tf.int32, name=\"decoder_targets\")\n",
    "        self.decoder_targets_length = tf.placeholder(shape=(None,), dtype=tf.int32, name=\"decoder_targets_length\")\n",
    "    \n",
    "    def _init_decoder_train_connectors(self):\n",
    "        \"\"\"\n",
    "        define the decoder's inputs and targets during training\n",
    "        \"\"\"\n",
    "        with tf.variable_scope(\"DecoderTrainFeeds\"):\n",
    "            sequence_size, batch_size = tf.unstack(tf.shape(self.decoder_targets))\n",
    "            \n",
    "            EOS_SLICE = tf.ones([1, batch_size], dtype=tf.int32) * self.EOS\n",
    "            PAD_SLICE = tf.ones([1, batch_size], dtype=tf.int32) * self.PAD\n",
    "            \n",
    "            # add EOS in the front of each decoder targets\n",
    "            self.decoder_train_inputs = tf.concat([EOS_SLICE, self.decoder_targets], axis=0)\n",
    "            self.decoder_train_length = self.decoder_targets_length + 1  # +1 stands for adding EOS tag\n",
    "            \n",
    "            # add PAD in the end of each decoder targets\n",
    "            decoder_train_targets = tf.concat([self.decoder_targets, PAD_SLICE], axis=0)\n",
    "            decoder_train_targets_seq_len, _ = tf.unstack(tf.shape(decoder_train_targets))\n",
    "            decoder_train_targets_eos_mask = tf.one_hot(self.decoder_train_length - 1, \\\n",
    "                                                        decoder_train_targets_seq_len, \\\n",
    "                                                        on_value=self.EOS, off_value=self.PAD, dtype=tf.int32)\n",
    "            \n",
    "            # change to time major\n",
    "            decoder_train_targets_eos_mask = tf.transpose(decoder_train_targets_eos_mask, [1, 0])\n",
    "            \n",
    "            # using one hot to put EOS symbol at the end of target sequence\n",
    "            decoder_train_targets = tf.add(decoder_train_targets, decoder_train_targets_eos_mask)\n",
    "            self.decoder_train_targets = decoder_train_targets\n",
    "            \n",
    "            self.loss_weights = tf.ones([batch_size, tf.reduce_max(self.decoder_train_length)], \\\n",
    "                                        dtype=tf.float32, name=\"loss_weights\")\n",
    "    \n",
    "    def _init_embeddings(self):\n",
    "        with tf.variable_scope(\"embedding\"):\n",
    "            sqrt3 = math.sqrt(3)\n",
    "            initializer = tf.random_uniform_initializer(-sqrt3, sqrt3)\n",
    "            \n",
    "            self.embedding_matrix = tf.get_variable(\"embedding_matrix\", \\\n",
    "                                                    shape=[self.vocab_size, self.embedding_size], \\\n",
    "                                                    initializer=initializer, dtype=tf.float32)\n",
    "            self.encoder_inputs_embedded = tf.nn.embedding_lookup(self.embedding_matrix, \\\n",
    "                                                                  self.encoder_inputs)\n",
    "            self.decoder_train_inputs_embedded = tf.nn.embedding_lookup(self.embedding_matrix, \\\n",
    "                                                                        self.decoder_train_inputs)\n",
    "    \n",
    "    def _init_simple_encoder(self):\n",
    "        with tf.variable_scope(\"Encoder\"):\n",
    "            (self.encoder_outputs, self.encoder_state) = tf.nn.dynamic_rnn(cell=self.encoder_cell, \\\n",
    "                                                                          inputs=self.encoder_inputs_embedded, \\\n",
    "                                                                          sequence_length=self.encoder_inputs_length, \\\n",
    "                                                                          time_major=True, dtype=tf.float32)\n",
    "    \n",
    "    def _init_bidirectional_encoder(self):\n",
    "        with tf.variable_scope(\"BidirectionalEncoder\"):\n",
    "            ((encoder_fw_outputs, encoder_bw_outputs),(encoder_fw_final_state, encoder_bw_final_state)) = \\\n",
    "            tf.nn.bidirectional_dynamic_rnn(cell_fw=self.encoder_cell, cell_bw=self.encoder_cell, \\\n",
    "                                            inputs=self.encoder_inputs_embedded, \\\n",
    "                                            sequence_length=self.encoder_inputs_length, \\\n",
    "                                            dtype=tf.float32, time_major=True)\n",
    "            \n",
    "            # concatenate forward and backward outputs\n",
    "            self.encoder_outputs = tf.concat((encoder_fw_outputs, encoder_bw_outputs), 2)\n",
    "            \n",
    "            # concatenate forward and backward final state\n",
    "            if isinstance(encoder_fw_final_state, LSTMStateTuple):\n",
    "                encoder_state_c = tf.concat((encoder_fw_final_state.c, encoder_bw_final_state.c), 1, \\\n",
    "                                            name=\"bidirectional_concat_c\")\n",
    "                encoder_state_h = tf.concat((encoder_fw_final_state.h, encoder_bw_final_state.h), 1, \\\n",
    "                                            name=\"bidirectional_concat_h\")\n",
    "                self.encoder_state = LSTMStateTuple(c=encoder_state_c, h=encoder_state_h)\n",
    "                \n",
    "            elif isinstance(encoder_fw_final_state, tf.Tensor):\n",
    "                self.encoder_state = tf.concat((encoder_fw_final_state, encoder_bw_final_state), 1, \\\n",
    "                                               name=\"bidirectional_concat\")\n",
    "                \n",
    "    \n",
    "    def _init_decoder(self):\n",
    "        with tf.variable_scope(\"Decoder\") as scope:\n",
    "            def output_fn(outputs):\n",
    "                return tf.contrib.layers.linear(outputs, self.vocab_size, scope=scope)\n",
    "            \n",
    "            # define both decoder_fn_train and decoder_fn_inference\n",
    "            if not self.attention:\n",
    "                decoder_fn_train = seq2seq.simple_decoder_fn_train(encoder_state=self.encoder_state)\n",
    "                decoder_fn_inference = seq2seq.simple_decoder_fn_inference(output_fn=output_fn, \\\n",
    "                                                                           encoder_state=self.encoder_state, \\\n",
    "                                                                           embeddings=self.embedding_matrix, \\\n",
    "                                                                           start_of_sequence_id=self.EOS, \\\n",
    "                                                                           end_of_sequence_id=self.EOS, \\\n",
    "                                                                           maximum_length=tf.reduce_max(\\\n",
    "                                                                                self.encoder_inputs_length) + 3, \\\n",
    "                                                                           num_decoder_symbols=self.vocab_size)\n",
    "            else:\n",
    "                # attention_states: [batch_size, max_time, num_units]\n",
    "                attention_states = tf.transpose(self.encoder_outputs, [1,0,2])\n",
    "                \n",
    "                (attention_keys, attention_values, attention_score_fn, attention_contruct_fn) = \\\n",
    "                seq2seq.prepare_attention(attention_states=attention_states, \\\n",
    "                                          attention_option=\"bahdanau\", \\\n",
    "                                          num_units=self.decoder_cell.output_size)\n",
    "                \n",
    "                decoder_fn_train = seq2seq.attention_decoder_fn_train(encoder_state=self.encoder_state, \\\n",
    "                                                                      attention_keys=attention_keys, \\\n",
    "                                                                      attention_values=attention_values, \\\n",
    "                                                                      attention_score_fn=attention_score_fn, \\\n",
    "                                                                      attention_construct_fn=attention_contruct_fn)\n",
    "                \n",
    "                decoder_fn_inference = seq2seq.attention_decoder_fn_inference(output_fn=output_fn, \\\n",
    "                                                                              encoder_state=self.encoder_state, \\\n",
    "                                                                              attention_keys=attention_keys, \\\n",
    "                                                                              attention_values=attention_values, \\\n",
    "                                                                              attention_score_fn=attention_score_fn, \\\n",
    "                                                                              attention_construct_fn=attention_contruct_fn, \\\n",
    "                                                                              embeddings=self.embedding_matrix, \\\n",
    "                                                                              start_of_sequence_id=self.EOS, \\\n",
    "                                                                              end_of_sequence_id=self.EOS, \\\n",
    "                                                                              maximum_length=tf.reduce_max(self.encoder_inputs_length) + 3, \\\n",
    "                                                                              num_decoder_symbols=self.vocab_size)\n",
    "            \n",
    "            # dynamic rnn decoder for train\n",
    "            # logits and prediction for train\n",
    "            (self.decoder_output_train, self.decoder_state_train, self.decoder_context_state_train) = \\\n",
    "            seq2seq.dynamic_rnn_decoder(cell=self.decoder_cell, decoder_fn=decoder_fn_train, \\\n",
    "                                        inputs=self.decoder_train_inputs_embedded, \\\n",
    "                                        sequence_length=self.decoder_train_length, \\\n",
    "                                        time_major=True, scope=scope)\n",
    "            \n",
    "            self.decoder_logits_train = output_fn(self.decoder_output_train)\n",
    "            self.decoder_prediction_train = tf.argmax(self.decoder_logits_train, axis=-1, name=\"decoder_prediction_train\")\n",
    "            \n",
    "            scope.reuse_variables()\n",
    "            \n",
    "            # dynamic rn decoder for inference\n",
    "            # prediction for inference\n",
    "            (self.decoder_logits_inference, self.decoder_state_inference, self.decoder_context_state_inference) = \\\n",
    "            seq2seq.dynamic_rnn_decoder(cell=self.decoder_cell, decoder_fn=decoder_fn_inference, \\\n",
    "                                        time_major=True, scope=scope)\n",
    "            \n",
    "            self.decoder_prediction_inference = tf.argmax(self.decoder_logits_inference, axis=-1, name='decoder_prediction_inference')\n",
    "    \n",
    "    def _init_optimizer(self):\n",
    "        logits = tf.transpose(self.decoder_logits_train, [1, 0, 2])\n",
    "        targets = tf.transpose(self.decoder_train_targets, [1, 0])\n",
    "        \n",
    "        self.loss = seq2seq.sequence_loss(logits=logits, targets=targets, weights=self.loss_weights)\n",
    "        self.train_op = tf.train.AdamOptimizer().minimize(self.loss)\n",
    "        \n",
    "    def make_train_inputs(self, input_seq, target_seq):\n",
    "        inputs_, inputs_length_ = helpers.batch(input_seq)\n",
    "        targets_, targets_length_ = helpers.batch(target_seq)\n",
    "        \n",
    "        return {self.encoder_inputs: inputs_, self.encoder_inputs_length: inputs_length_, \\\n",
    "                self.decoder_targets: targets_, self.decoder_targets_length: targets_length_}\n",
    "    \n",
    "    def make_inference_inputs(self, input_seq):\n",
    "        inputs_, inputs_length_ = helpers.batch(input_seq)\n",
    "        \n",
    "        return {self.encoder_inputs: inputs_, self.encoder_inputs_length: inputs_length_}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def make_seq2seq_model(**kwargs):\n",
    "    args = dict(encoder_cell=LSTMCell(10), decoder_cell=LSTMCell(20), vocab_size=10, embedding_size=10, \\\n",
    "                attention=True, bidirectional=True, debug=False)\n",
    "    args.update(kwargs)\n",
    "    return Seq2SeqModel(**args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_on_copy_task(sess, model, \n",
    "                       length_from=3, length_to=8, \n",
    "                       vocab_lower=2, vocab_upper=10, \n",
    "                       batch_size = 100, max_batches=5000, \n",
    "                       batches_in_epoch=1000, verbose=True):\n",
    "    \n",
    "    batches = helpers.random_sequences(length_from=length_from, length_to=length_to, \n",
    "                                       vocab_lower=vocab_lower, vocab_upper=vocab_upper, \n",
    "                                       batch_size=batch_size)\n",
    "    \n",
    "    loss_history = []\n",
    "    \n",
    "    try:\n",
    "        for batch in range(max_batches + 1):\n",
    "            batch_data = next(batches)\n",
    "            \n",
    "            # training for copying task\n",
    "            # both the input and target sequence are the same\n",
    "            fd = model.make_train_inputs(batch_data, batch_data)\n",
    "            _, loss = sess.run([model.train_op, model.loss], fd)\n",
    "            loss_history.append(loss)\n",
    "            \n",
    "            if verbose:\n",
    "                if batch == 0 or batch % batches_in_epoch == 0:\n",
    "                    print('batch: {}'.format(batch))\n",
    "                    print('minibatch loss: {}'.format(sess.run(model.loss, fd)))\n",
    "                    for i, (enc_input, dec_pred) in \\\n",
    "                        enumerate(zip(fd[model.encoder_inputs].T, sess.run(model.decoder_prediction_train, fd).T)):\n",
    "                        print('Sample: {}'.format(i + 1))\n",
    "                        print('encoder input: {}'.format(enc_input))\n",
    "                        print('decoder train predicted: {}'.format(dec_pred))\n",
    "                        # it is necessary to output the first data as the example\n",
    "                        if i >= 2:\n",
    "                            break\n",
    "                    print()\n",
    "            \n",
    "    except KeyboardInterrupt:\n",
    "        print(\"Training interrupted.\")\n",
    "        \n",
    "    return loss_history\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "types = \"train\"\n",
    "\n",
    "if types == \"fw-debug\":\n",
    "    \n",
    "    tf.reset_default_graph()\n",
    "    with tf.Session() as sess:\n",
    "        model = make_seq2seq_model(debug=True)\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        print(\"Debug Input:\")\n",
    "        print(sess.run(model.encoder_inputs))\n",
    "        print(\"Debug Pred:\")\n",
    "        print(sess.run(model.decoder_prediction_train))\n",
    "    \n",
    "elif types == \"fw-inf\":\n",
    "    \n",
    "    tf.reset_default_graph()\n",
    "    with tf.Session() as sess:\n",
    "        model = make_seq2seq_model()\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        fd = model.make_inference_inputs([[3, 7, 6, 8], [7,7]])\n",
    "        inference = sess.run(model.decoder_prediction_inference, fd)\n",
    "        print(inference)\n",
    "    \n",
    "elif types == \"train\":\n",
    "    tracks = {}\n",
    "    \n",
    "    # train with attention \n",
    "    tf.reset_default_graph()\n",
    "    with tf.Session() as sess:\n",
    "        model = make_seq2seq_model(attention=True)\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        loss_track_attention = train_on_copy_task(sess, model)\n",
    "    plt.plot(loss_track_attention, label='attention')\n",
    "    print('loss {:.4f}'.format(loss_track_attention[-1]))\n",
    "    \n",
    "    # train without attention\n",
    "    tf.reset_default_graph()\n",
    "    with tf.Session() as sess:\n",
    "        model = make_seq2seq_model(attention=False)\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        loss_track_no_attention = train_on_copy_task(sess, model)\n",
    "    plt.plot(loss_track_no_attention, label='no attention')\n",
    "    print('loss {:.4f}'.format(loss_track_no_attention[-1]))\n",
    "    \n",
    "    plt.legend()\n",
    "    \n",
    "else:\n",
    "    \n",
    "    tf.reset_default_graph()\n",
    "    sess = tf.InteractiveSession()\n",
    "    model = make_seq2seq_model(debug=False)\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    \n",
    "    fd = model.make_inference_inputs([[3, 7, 6, 8],[7,3]])\n",
    "    inference, = sess.run([model.decoder_prediction_inference], fd)\n",
    "    print(inference)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Seq2Seq Compare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LSTMCell Consisting Bidirectional Dynamic RNN with Attention Mechanism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batch: 0\n",
      "minibatch loss: 2.3217923641204834\n",
      "Sample: 1\n",
      "encoder input: [5 2 7 8 6 0 0 0]\n",
      "decoder train predicted: [6 6 0 5 5 0 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [9 5 6 3 2 2 4 0]\n",
      "decoder train predicted: [6 6 6 6 6 6 6 6 0]\n",
      "Sample: 3\n",
      "encoder input: [9 4 5 2 6 6 8 0]\n",
      "decoder train predicted: [6 6 6 6 6 6 6 6 0]\n",
      "\n",
      "batch: 1000\n",
      "minibatch loss: 0.24910122156143188\n",
      "Sample: 1\n",
      "encoder input: [7 8 6 6 7 0 0 0]\n",
      "decoder train predicted: [7 8 6 6 7 1 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [3 2 6 0 0 0 0 0]\n",
      "decoder train predicted: [3 2 6 1 0 0 0 0 0]\n",
      "Sample: 3\n",
      "encoder input: [2 7 8 4 2 6 5 0]\n",
      "decoder train predicted: [2 7 8 4 2 6 5 1 0]\n",
      "\n",
      "batch: 2000\n",
      "minibatch loss: 0.09602542221546173\n",
      "Sample: 1\n",
      "encoder input: [3 7 7 0 0 0 0 0]\n",
      "decoder train predicted: [3 7 7 1 0 0 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [8 8 8 3 4 3 4 0]\n",
      "decoder train predicted: [8 8 8 3 4 3 4 1 0]\n",
      "Sample: 3\n",
      "encoder input: [5 5 9 0 0 0 0 0]\n",
      "decoder train predicted: [5 5 9 1 0 0 0 0 0]\n",
      "\n",
      "batch: 3000\n",
      "minibatch loss: 0.04288767650723457\n",
      "Sample: 1\n",
      "encoder input: [3 8 5 7 0 0 0 0]\n",
      "decoder train predicted: [3 8 5 7 1 0 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [9 7 3 8 3 0 0 0]\n",
      "decoder train predicted: [9 7 3 8 3 1 0 0 0]\n",
      "Sample: 3\n",
      "encoder input: [2 5 9 4 4 3 3 4]\n",
      "decoder train predicted: [2 5 9 4 4 3 3 4 1]\n",
      "\n",
      "batch: 4000\n",
      "minibatch loss: 0.019865084439516068\n",
      "Sample: 1\n",
      "encoder input: [4 2 6 8 4 0 0 0]\n",
      "decoder train predicted: [4 2 6 8 4 1 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [9 7 8 7 6 8 2 4]\n",
      "decoder train predicted: [9 7 8 7 6 8 2 4 1]\n",
      "Sample: 3\n",
      "encoder input: [5 9 2 9 8 0 0 0]\n",
      "decoder train predicted: [5 9 2 9 8 1 0 0 0]\n",
      "\n",
      "batch: 5000\n",
      "minibatch loss: 0.009693838655948639\n",
      "Sample: 1\n",
      "encoder input: [5 6 4 9 8 5 2 6]\n",
      "decoder train predicted: [5 6 4 9 8 5 2 6 1]\n",
      "Sample: 2\n",
      "encoder input: [5 8 9 3 0 0 0 0]\n",
      "decoder train predicted: [5 8 9 3 1 0 0 0 0]\n",
      "Sample: 3\n",
      "encoder input: [8 2 9 0 0 0 0 0]\n",
      "decoder train predicted: [8 2 9 1 0 0 0 0 0]\n",
      "\n",
      "loss 0.0097\n",
      "batch: 0\n",
      "minibatch loss: 2.2829031944274902\n",
      "Sample: 1\n",
      "encoder input: [5 3 8 7 0 0 0 0]\n",
      "decoder train predicted: [7 7 7 4 9 0 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [7 4 8 5 7 6 4 0]\n",
      "decoder train predicted: [7 5 8 4 4 5 4 8 0]\n",
      "Sample: 3\n",
      "encoder input: [8 9 3 7 2 6 4 0]\n",
      "decoder train predicted: [5 9 5 7 5 5 4 1 0]\n",
      "\n",
      "batch: 1000\n",
      "minibatch loss: 0.5305114984512329\n",
      "Sample: 1\n",
      "encoder input: [8 7 2 7 3 6 4 8]\n",
      "decoder train predicted: [8 7 2 7 6 6 4 6 1]\n",
      "Sample: 2\n",
      "encoder input: [9 8 8 3 3 3 0 0]\n",
      "decoder train predicted: [8 8 3 3 3 3 1 0 0]\n",
      "Sample: 3\n",
      "encoder input: [3 2 3 9 3 4 5 0]\n",
      "decoder train predicted: [3 3 3 9 3 4 5 1 0]\n",
      "\n",
      "batch: 2000\n",
      "minibatch loss: 0.2574673593044281\n",
      "Sample: 1\n",
      "encoder input: [6 5 8 2 2 0 0 0]\n",
      "decoder train predicted: [6 5 2 2 2 1 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [9 5 5 9 8 6 9 0]\n",
      "decoder train predicted: [9 5 9 9 8 6 9 1 0]\n",
      "Sample: 3\n",
      "encoder input: [5 2 6 5 0 0 0 0]\n",
      "decoder train predicted: [5 2 6 5 1 0 0 0 0]\n",
      "\n",
      "batch: 3000\n",
      "minibatch loss: 0.1461225003004074\n",
      "Sample: 1\n",
      "encoder input: [4 2 9 7 7 0 0 0]\n",
      "decoder train predicted: [4 2 9 7 7 1 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [2 8 4 8 5 9 5 0]\n",
      "decoder train predicted: [2 8 4 8 5 9 5 1 0]\n",
      "Sample: 3\n",
      "encoder input: [5 4 5 9 8 6 8 0]\n",
      "decoder train predicted: [5 4 5 9 8 6 8 1 0]\n",
      "\n",
      "batch: 4000\n",
      "minibatch loss: 0.09475734084844589\n",
      "Sample: 1\n",
      "encoder input: [6 4 2 9 6 0 0 0]\n",
      "decoder train predicted: [6 4 2 9 6 1 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [4 8 7 7 3 0 0 0]\n",
      "decoder train predicted: [4 8 7 7 3 1 0 0 0]\n",
      "Sample: 3\n",
      "encoder input: [6 3 9 0 0 0 0 0]\n",
      "decoder train predicted: [6 3 9 1 0 0 0 0 0]\n",
      "\n",
      "batch: 5000\n",
      "minibatch loss: 0.06706323474645615\n",
      "Sample: 1\n",
      "encoder input: [8 3 4 3 2 0 0 0]\n",
      "decoder train predicted: [8 3 4 3 2 1 0 0 0]\n",
      "Sample: 2\n",
      "encoder input: [3 9 6 3 3 0 0 0]\n",
      "decoder train predicted: [3 9 6 3 3 1 0 0 0]\n",
      "Sample: 3\n",
      "encoder input: [4 3 9 9 7 0 0 0]\n",
      "decoder train predicted: [4 3 9 9 7 1 0 0 0]\n",
      "\n",
      "loss 0.0705\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f72949b8e80>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f729942f7f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tf.set_random_seed(3)\n",
    "\n",
    "# train with attention \n",
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    model = make_seq2seq_model(encoder_cell=LSTMCell(10), decoder_cell=LSTMCell(20), \n",
    "                               vocab_size=10, embedding_size=10, attention=True, bidirectional=True, debug=False)\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    loss_track_attention = train_on_copy_task(sess, model)\n",
    "plt.plot(loss_track_attention, label='attention')\n",
    "print('loss {:.4f}'.format(loss_track_attention[-1]))\n",
    "\n",
    "# train without attention\n",
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    model = make_seq2seq_model(encoder_cell=LSTMCell(10), decoder_cell=LSTMCell(20), \n",
    "                               vocab_size=10, embedding_size=10, attention=False, bidirectional=True, debug=False)\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    loss_track_no_attention = train_on_copy_task(sess, model)\n",
    "plt.plot(loss_track_no_attention, label='no attention')\n",
    "print('loss {:.4f}'.format(loss_track_no_attention[-1]))\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Forward / Bidirectional Encoder Combining No Attention / Attention "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss 0.1940\n",
      "loss 0.0139\n",
      "loss 0.0604\n",
      "loss 0.0122\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f75389226a0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\no9HEIP8PW72vsItW7AQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f753897fcc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tf.set_random_seed(3)\n",
    "\n",
    "# Forward + No Attention\n",
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    model = make_seq2seq_model(encoder_cell=LSTMCell(10), decoder_cell=LSTMCell(10), \n",
    "                               vocab_size=10, embedding_size=10, attention=False, bidirectional=False, debug=False)\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    Forward_No_Attention = train_on_copy_task(sess, model, verbose=False)\n",
    "plt.plot(Forward_No_Attention, label='Forward_No_Attention')\n",
    "print('loss {:.4f}'.format(Forward_No_Attention[-1]))\n",
    "\n",
    "# Forward + Attention\n",
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    model = make_seq2seq_model(encoder_cell=LSTMCell(10), decoder_cell=LSTMCell(10), \n",
    "                               vocab_size=10, embedding_size=10, attention=True, bidirectional=False, debug=False)\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    Forward_Attention = train_on_copy_task(sess, model, verbose=False)\n",
    "plt.plot(Forward_Attention, label='Forward_Attention')\n",
    "print('loss {:.4f}'.format(Forward_Attention[-1]))\n",
    "\n",
    "# Bidirectional + No Attention\n",
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    model = make_seq2seq_model(encoder_cell=LSTMCell(10), decoder_cell=LSTMCell(20), \n",
    "                               vocab_size=10, embedding_size=10, attention=False, bidirectional=True, debug=False)\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    Bidirectional_No_Attention = train_on_copy_task(sess, model, verbose=False)\n",
    "plt.plot(Bidirectional_No_Attention, label='Bidirectional_No_Attention')\n",
    "print('loss {:.4f}'.format(Bidirectional_No_Attention[-1]))\n",
    "\n",
    "# Bidirectional + Attention\n",
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    model = make_seq2seq_model(encoder_cell=LSTMCell(10), decoder_cell=LSTMCell(20), \n",
    "                               vocab_size=10, embedding_size=10, attention=True, bidirectional=True, debug=False)\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    Bidirectional_Attention = train_on_copy_task(sess, model, verbose=False)\n",
    "plt.plot(Bidirectional_Attention, label='Bidirectional_Attention')\n",
    "print('loss {:.4f}'.format(Bidirectional_Attention[-1]))\n",
    "\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above result, the DNN with both the bidirectional and the attention is the best practice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LSTMCell / GRUCell in Bidirectional Dynamic RNN with Attention Mechanism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import time\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tf.set_random_seed(3)\n",
    "\n",
    "# LSTM Cell\n",
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    model = make_seq2seq_model(encoder_cell=LSTMCell(10), decoder_cell=LSTMCell(20), \n",
    "                               vocab_size=10, embedding_size=10, attention=True, bidirectional=True, debug=False)\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    start = time.time()\n",
    "    LSTM_Loss = train_on_copy_task(sess, model, verbose=False) \n",
    "    lstm_train_peroid = time.time() - start\n",
    "    \n",
    "# GRU Cell\n",
    "tf.reset_default_graph()\n",
    "with tf.Session() as sess:\n",
    "    model = make_seq2seq_model(encoder_cell=GRUCell(10), decoder_cell=GRUCell(20), \n",
    "                               vocab_size=10, embedding_size=10, attention=True, bidirectional=True, debug=False)\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    start = time.time()\n",
    "    GRU_Loss = train_on_copy_task(sess, model, verbose=False) \n",
    "    gru_train_peroid = time.time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "lstm = pd.Series(LSTM_Loss, name='lstm')\n",
    "gru = pd.Series(GRU_Loss, name='gru')\n",
    "loss_batch = pd.DataFrame(dict(lstm=lstm, gru=gru))\n",
    "loss_batch.index.name = 'batch'\n",
    "\n",
    "lstm.index = lstm.index / lstm_train_peroid\n",
    "gru.index = gru.index / gru_train_peroid\n",
    "tracks_time = pd.DataFrame(dict(lstm=lstm, gru=gru)).ffill()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f7549cdbc50>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAGDCAYAAADpvl4eAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkiT1xGAlSZLUE4OVJElSTwxWkiRJPfkLrBs6+PVreZEAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f753a659ac8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "loss_batch.plot(figsize=(10,6), title=\"LSTM vs GRU Loss, batch-time\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f75383099b0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAF1CAYAAAAqdaQaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\npE+UWImIiIj0yX90R/UBjyEP4wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f753a6e0630>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tracks_time.plot(figsize=(10, 6), title=\"LSTM vs GRU loss, compute-time\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above experiment, it's showed that GRU provides better training performance in compute-time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}