word_classifier_seq2seq.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training: Sequence to Sequence Model - Word Classification\n",
    "Training sequence to sequnce model for recognition of words.\n",
    "## TODO\n",
    "```\n",
    "REMOVE embeddings\n",
    "Overlaping sliders\n",
    "One-shot preprocessing\n",
    "Train preprocessing with RNN\n",
    "lower extra steps, bigger hState, preprocessing?\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import cv2\n",
    "import matplotlib as plt\n",
    "import tensorflow as tf\n",
    "import tensorflow.contrib.seq2seq as seq2seq\n",
    "from tensorflow.python.layers import core as layers_core\n",
    "import time\n",
    "import math\n",
    "import unidecode\n",
    "\n",
    "sys.path.append('src')\n",
    "from ocr.datahelpers import load_words_data, corresponding_shuffle, char2idx\n",
    "from ocr.helpers import img_extend\n",
    "from ocr.mlhelpers import TrainingPlot\n",
    "from ocr.tfhelpers import create_cell\n",
    "from ocr.imgtransform import coordinates_remap\n",
    "\n",
    "%matplotlib notebook\n",
    "plt.rcParams['figure.figsize'] = (9.0, 5.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "LANG = 'en'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading words...\n",
      " |████████████████████████████████████████| 100.0% \n",
      "-> Number of words: 5069\n"
     ]
    }
   ],
   "source": [
    "images, labels = load_words_data(\n",
    "    ['data/processed/breta/words_gaplines/'], load_gaplines=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "char_size = 82 if LANG =='cz' else 52\n",
    "\n",
    "PAD = 0   # Padding\n",
    "EOS = 1   # End of seq\n",
    "\n",
    "num_new_images = 2                 #  Number of new images per image\n",
    "fac_alpha = 2.0                    # Factors for image preprocessing\n",
    "fac_sigma = 0.08\n",
    "\n",
    "num_buckets = 5\n",
    "slider_size = (60, 2)\n",
    "N_INPUT = 60*2                     # Size of sequence input vector\n",
    "vocab_size = char_size + 2         # Number of different chars + <PAD> and <EOS>\n",
    "input_embedding_size = vocab_size  # Size of vector for embedding chars2vec\n",
    "\n",
    "\n",
    "encoder_layers = 2\n",
    "decoder_layers = 2*encoder_layers  # 2* is due to the bidirectional encoder\n",
    "encoder_residual_layers = 1        # HAVE TO be smaller than encoder_layers\n",
    "decoder_residual_layers = 2*encoder_residual_layers\n",
    "encoder_units = 256\n",
    "decoder_units = encoder_units\n",
    "\n",
    "add_output_length = 4 # 4\n",
    "\n",
    "learning_rate = 1e-4               # 1e-4\n",
    "max_gradient_norm = 5.0            # For gradient clipping\n",
    "dropout = 0.4\n",
    "train_per = 0.8                    # Percentage of training data\n",
    "\n",
    "TRAIN_STEPS = 100000               # Number of training steps!\n",
    "TEST_ITER = 150\n",
    "LOSS_ITER = 50\n",
    "SAVE_ITER = 2000\n",
    "BATCH_SIZE = 64\n",
    "EPOCH = 2000                       # Number of batches in epoch - not accurate\n",
    "\n",
    "save_location = 'models/word-clas/' + LANG + '/WordClassifier2'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training images: 4055\n",
      "Testing images: 1014\n"
     ]
    }
   ],
   "source": [
    "# Shuffle data for later splitting\n",
    "images, labels = corresponding_shuffle([images, labels])\n",
    "\n",
    "labels_idx = np.empty(len(labels), dtype=object)\n",
    "for i, label in enumerate(labels):\n",
    "    labels_idx[i] = [char2idx(c, True) for c in label]\n",
    "    \n",
    "# Split data on train and test dataset\n",
    "div = int(train_per * len(images))\n",
    "\n",
    "trainImages = images[0:div]\n",
    "testImages = images[div:]\n",
    "\n",
    "trainLabels_idx = labels_idx[0:div]\n",
    "testLabels_idx = labels_idx[div:]\n",
    "\n",
    "print(\"Training images:\", div)\n",
    "print(\"Testing images:\", len(images) - div)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset extending"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transformed train images 12165\n"
     ]
    }
   ],
   "source": [
    "# Dont mix train and test images\n",
    "trainImagesFinal = np.empty(len(trainImages) * (num_new_images+1), dtype=object)\n",
    "trainLabelsFinal_idx = np.empty(len(trainImages)*(num_new_images+1), dtype=object)\n",
    "for idx, img in enumerate(trainImages):\n",
    "    trainImagesFinal[idx*(num_new_images+1)] = img\n",
    "    trainLabelsFinal_idx[idx*(num_new_images+1)] = trainLabels_idx[idx]\n",
    "    for i in range(num_new_images):\n",
    "        trainImagesFinal[idx*(num_new_images+1) + (i+1)] = coordinates_remap(img, fac_alpha, fac_sigma)\n",
    "        trainLabelsFinal_idx[idx*(num_new_images+1) + (i+1)] = trainLabels_idx[idx]\n",
    "        \n",
    "print(\"Transformed train images\", len(trainImagesFinal))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BucketDataIterator():\n",
    "    \"\"\" Iterator for feeding seq2seq model during training \"\"\"\n",
    "    def __init__(self,\n",
    "                 images,\n",
    "                 targets,\n",
    "                 num_buckets=5,\n",
    "                 slider=(60, 30),\n",
    "                 train=True):\n",
    "        \n",
    "        self.train = train\n",
    "        \n",
    "        # First PADDING of images to slider size ( -(a // b) ==  ceil(a/b))\n",
    "        self.slider = slider\n",
    "        for i in range(len(images)):\n",
    "            images[i] = img_extend(\n",
    "                images[i],\n",
    "                (images[i].shape[0], -(-images[i].shape[1] // slider[1]) * slider[1]))\n",
    "        in_length = [image.shape[1]//slider[1] for image in images]\n",
    "        \n",
    "        # Split images to sequence of vectors\n",
    "        imgseq = np.empty(len(images), dtype=object)\n",
    "        for i, img in enumerate(images):\n",
    "            imgseq[i] = [img[:, loc * slider[1]: (loc+1) * slider[1]].flatten()\n",
    "                         for loc in range(in_length[i])]\n",
    "\n",
    "        # Create pandas dataFrame and sort it by images width (length) \n",
    "        self.dataFrame = pd.DataFrame({'in_length': in_length,\n",
    "                                       'out_length': [len(t) for t in targets],\n",
    "                                       'images': imgseq,\n",
    "                                       'targets': targets\n",
    "                                      }).sort_values('in_length').reset_index(drop=True)\n",
    "\n",
    "        bsize = int(len(images) / num_buckets)\n",
    "        self.num_buckets = num_buckets\n",
    "        \n",
    "        # Create buckets by slicing parts by indexes\n",
    "        self.buckets = []\n",
    "        for bucket in range(num_buckets-1):\n",
    "            self.buckets.append(self.dataFrame.iloc[bucket * bsize: (bucket+1) * bsize])\n",
    "        self.buckets.append(self.dataFrame.iloc[(num_buckets-1) * bsize:])        \n",
    "        \n",
    "        self.buckets_size = [len(bucket) for bucket in self.buckets]\n",
    "\n",
    "        # cursor[i] will be the cursor for the ith bucket\n",
    "        self.cursor = np.array([0] * num_buckets)\n",
    "        self.bucket_order = np.random.permutation(num_buckets)\n",
    "        self.bucket_cursor = 0\n",
    "        self.shuffle()\n",
    "        print(\"Iterator created.\")\n",
    "\n",
    "    def shuffle(self, idx=None):\n",
    "        \"\"\" Shuffle idx bucket or each bucket separately \"\"\"\n",
    "        for i in [idx] if idx is not None else range(self.num_buckets):\n",
    "            self.buckets[i] = self.buckets[i].sample(frac=1).reset_index(drop=True)\n",
    "            self.cursor[i] = 0\n",
    "\n",
    "\n",
    "    def next_batch(self, batch_size):\n",
    "        \"\"\"\n",
    "        Creates next training batch of size: batch_size\n",
    "        Retruns: image seq, letter seq,\n",
    "                 image seq lengths, letter seq lengths\n",
    "        \"\"\"\n",
    "        i_bucket = self.bucket_order[self.bucket_cursor]\n",
    "        # Increment cursor and shuffle in case of new round\n",
    "        self.bucket_cursor = (self.bucket_cursor + 1) % self.num_buckets\n",
    "        if self.bucket_cursor == 0:\n",
    "            self.bucket_order = np.random.permutation(self.num_buckets)\n",
    "            \n",
    "        if self.cursor[i_bucket] + batch_size > self.buckets_size[i_bucket]:\n",
    "            self.shuffle(i_bucket)\n",
    "\n",
    "        # Handle too big batch sizes\n",
    "        if (batch_size > self.buckets_size[i_bucket]):\n",
    "            batch_size = self.buckets_size[i_bucket]\n",
    "\n",
    "        res = self.buckets[i_bucket].iloc[self.cursor[i_bucket]:\n",
    "                                          self.cursor[i_bucket]+batch_size]\n",
    "        self.cursor[i_bucket] += batch_size\n",
    "\n",
    "        # PAD input sequence and output\n",
    "        # Pad sequences with <PAD> to same length\n",
    "        input_max = max(res['in_length'])\n",
    "        output_max = max(res['out_length'])\n",
    "        # In order to make it work at production\n",
    "        assert np.all(res['in_length'] + add_output_length >= res['out_length'])\n",
    "        \n",
    "        input_seq = np.zeros((batch_size, input_max, N_INPUT), dtype=np.float32)\n",
    "        for i, img in enumerate(res['images']):\n",
    "            input_seq[i][:res['in_length'].values[i]] = img\n",
    "        input_seq = input_seq.swapaxes(0, 1)\n",
    "        \n",
    "        # Need to pad according to the maximum length output sequence\n",
    "        targets = np.zeros([batch_size, output_max], dtype=np.int32)\n",
    "        for i, target in enumerate(targets):\n",
    "            target[:res['out_length'].values[i]] = res['targets'].values[i]\n",
    "        targets = targets.swapaxes(0, 1)\n",
    "        \n",
    "        return input_seq, targets, res['in_length'].values, res['out_length'].values\n",
    "    \n",
    "    def next_feed(self, size):\n",
    "        \"\"\" Create feed directly for model training \"\"\"\n",
    "        (encoder_inputs_,\n",
    "         decoder_targets_,\n",
    "         encoder_inputs_length_,\n",
    "         decoder_targets_length_) = self.next_batch(size)\n",
    "        return {\n",
    "            encoder_inputs: encoder_inputs_,\n",
    "            encoder_inputs_length: encoder_inputs_length_,\n",
    "            decoder_targets: decoder_targets_,\n",
    "            decoder_targets_length: decoder_targets_length_,\n",
    "            keep_prob: (1.0 - dropout) if self.train else 1.0\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iterator created.\n",
      "Iterator created.\n"
     ]
    }
   ],
   "source": [
    "# Create iterator for feeding RNN\n",
    "# Create only once, it modifies: labels_idx\n",
    "train_iterator = BucketDataIterator(trainImagesFinal,\n",
    "                                    trainLabelsFinal_idx,\n",
    "                                    num_buckets,\n",
    "                                    slider_size,\n",
    "                                    train=True)\n",
    "test_iterator = BucketDataIterator(testImages,\n",
    "                                   testLabels_idx,\n",
    "                                   num_buckets,\n",
    "                                   slider_size,\n",
    "                                   train=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Placeholders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input placehodlers\n",
    "# N_INPUT -> size of vector representing one image in sequence\n",
    "# Encoder inputs shape (max_seq_length, batch_size, vec_size)\n",
    "encoder_inputs = tf.placeholder(shape=(None, None, N_INPUT),\n",
    "                                dtype=tf.float32,\n",
    "                                name='encoder_inputs')\n",
    "encoder_inputs_length = tf.placeholder(shape=(None,),\n",
    "                                       dtype=tf.int32,\n",
    "                                       name='encoder_inputs_length')\n",
    "# required for training, not required for testing and application\n",
    "decoder_targets = tf.placeholder(shape=(None, None),\n",
    "                                 dtype=tf.int32,\n",
    "                                 name='decoder_targets')\n",
    "decoder_targets_length = tf.placeholder(shape=(None,),\n",
    "                                        dtype=tf.int32,\n",
    "                                        name='decoder_targets_length')\n",
    "# Dropout value\n",
    "keep_prob = tf.placeholder(tf.float32, name='keep_prob')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decoder Train Feeds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence_size, batch_size = tf.unstack(tf.shape(decoder_targets))\n",
    "\n",
    "test_length = tf.floor_div(tf.reduce_max(encoder_inputs_length), 7) + add_output_length\n",
    "\n",
    "EOS_SLICE = tf.ones([1, batch_size], dtype=tf.int32) * EOS\n",
    "PAD_SLICE = tf.ones([1, batch_size], dtype=tf.int32) * PAD\n",
    "\n",
    "# Train inputs with EOS symbol at start of seq\n",
    "decoder_train_inputs = tf.concat([EOS_SLICE, decoder_targets], axis=0)\n",
    "decoder_train_length = decoder_targets_length + 1\n",
    "\n",
    "# train targets with EOS symbol at end of seq\n",
    "decoder_train_targets = tf.concat([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(decoder_train_length - 1,\n",
    "                                            decoder_train_targets_seq_len,\n",
    "                                            on_value=EOS, off_value=PAD,\n",
    "                                            dtype=tf.int32)\n",
    "decoder_train_targets_eos_mask = tf.transpose(decoder_train_targets_eos_mask, [1, 0])\n",
    "\n",
    "# hacky way using one_hot to put EOS symbol at the end of target sequence\n",
    "decoder_train_targets = tf.add(decoder_train_targets,\n",
    "                               decoder_train_targets_eos_mask)\n",
    "\n",
    "# Pad test accuracy\n",
    "decoder_test_targets = tf.pad(\n",
    "    decoder_train_targets,\n",
    "    [[0, test_length - decoder_train_targets_seq_len], [0, 0]],\n",
    "    mode='CONSTANT')\n",
    "\n",
    "loss_weights = tf.sequence_mask(\n",
    "    decoder_train_length,\n",
    "    tf.reduce_max(decoder_train_length),\n",
    "    dtype=tf.float32)\n",
    "\n",
    "test_weights = tf.sequence_mask(\n",
    "    decoder_train_length,\n",
    "    test_length,\n",
    "    dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Randomly initialized embedding matrix, for characters embedding in decoder\n",
    "embeddings = tf.Variable(tf.random_uniform([vocab_size,\n",
    "                                            input_embedding_size],\n",
    "                                           -1.0, 1.0), dtype=tf.float32)\n",
    "\n",
    "decoder_train_inputs_embedded = tf.nn.embedding_lookup(\n",
    "    embeddings, decoder_train_inputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "enc_cell_fw = create_cell(encoder_units,\n",
    "                          encoder_layers,\n",
    "                          encoder_residual_layers,\n",
    "                          is_dropout=True,\n",
    "                          keep_prob=keep_prob)\n",
    "enc_cell_bw = create_cell(encoder_units,\n",
    "                          encoder_layers,\n",
    "                          encoder_residual_layers,\n",
    "                          is_dropout=True,\n",
    "                          keep_prob=keep_prob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Help functions for standard layers\n",
    "def conv2d(x, W, name=None):\n",
    "    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME', name=name)\n",
    "\n",
    "def max_pool_2x2(x, name=None):\n",
    "    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME', name=name)\n",
    "\n",
    "# 1. Layer - Convulation variables\n",
    "W_conv1 = tf.get_variable('W_conv1', shape=[5, 5, 1, 4],\n",
    "                          initializer=tf.contrib.layers.xavier_initializer())\n",
    "b_conv1 = tf.Variable(tf.constant(0.1, shape=[4]), name='b_conv1')\n",
    "# 3. Layer - Convulation variables\n",
    "W_conv2 = tf.get_variable('W_conv2', shape=[5, 5, 4, 8],\n",
    "                          initializer=tf.contrib.layers.xavier_initializer())\n",
    "b_conv2 = tf.Variable(tf.constant(0.1, shape=[8]), name='b_conv2')\n",
    "\n",
    "def CNN(x):\n",
    "    x = tf.image.per_image_standardization(x)\n",
    "    x_img = tf.reshape(x, [1, slider_size[0], slider_size[1], 1])\n",
    "    # 1. Layer - Convulation\n",
    "    h_conv1 = tf.nn.relu(conv2d(x_img, W_conv1) + b_conv1, name='h_conv1')\n",
    "    # 2. Layer - Max Pool\n",
    "    h_pool1 = max_pool_2x2(h_conv1, name='h_pool1')\n",
    "    # 3. Layer - Convulation\n",
    "    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2, name='h_conv2')\n",
    "    # 4. Layer - Max Pool\n",
    "    return max_pool_2x2(h_conv2, name='h_pool2')\n",
    "\n",
    "# Input images CNN\n",
    "inputs = tf.map_fn(\n",
    "    lambda seq: tf.map_fn(\n",
    "        lambda img:\n",
    "            tf.reshape(\n",
    "                CNN(tf.reshape(img, [slider_size[0], slider_size[1], 1])), [-1]),\n",
    "        seq),\n",
    "    encoder_inputs,\n",
    "    dtype=tf.float32)\n",
    "\n",
    "# Bidirectional RNN, gibe fw and bw outputs separately\n",
    "enc_outputs, enc_state = tf.nn.bidirectional_dynamic_rnn(\n",
    "    cell_fw = enc_cell_fw,\n",
    "    cell_bw = enc_cell_bw,\n",
    "    inputs = inputs,\n",
    "    sequence_length = encoder_inputs_length,\n",
    "    dtype = tf.float32,\n",
    "    time_major = True)\n",
    "\n",
    "encoder_outputs = tf.concat(enc_outputs, -1)\n",
    "\n",
    "if encoder_layers == 1:\n",
    "    encoder_state = enc_state\n",
    "else:\n",
    "    encoder_state = []\n",
    "    for layer_id in range(encoder_layers):\n",
    "        encoder_state.append(enc_state[0][layer_id])  # forward\n",
    "        encoder_state.append(enc_state[1][layer_id])  # backward\n",
    "    encoder_state = tuple(encoder_state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# attention_states: size [batch_size, max_time, num_units]\n",
    "attention_states = tf.transpose(encoder_outputs, [1, 0, 2])\n",
    "\n",
    "# Create an attention mechanism\n",
    "attention_mechanism = tf.contrib.seq2seq.LuongAttention(\n",
    "    decoder_units, attention_states,\n",
    "    memory_sequence_length=encoder_inputs_length)\n",
    "\n",
    "\n",
    "decoder_cell = create_cell(decoder_units,\n",
    "                           decoder_layers,\n",
    "                           decoder_residual_layers,\n",
    "                           is_dropout=True,\n",
    "                           keep_prob=keep_prob)\n",
    "\n",
    "decoder_cell = seq2seq.AttentionWrapper(\n",
    "    decoder_cell, attention_mechanism,\n",
    "    attention_layer_size=decoder_units)\n",
    "\n",
    "decoder_initial_state = decoder_cell.zero_state(batch_size, tf.float32).clone(\n",
    "    cell_state=encoder_state)\n",
    "\n",
    "### TRAIN DECODER ###\n",
    "# Helper\n",
    "helper = seq2seq.TrainingHelper(\n",
    "    decoder_train_inputs_embedded, decoder_train_length, time_major=True)\n",
    "\n",
    "# Decoder\n",
    "projection_layer = layers_core.Dense(\n",
    "    vocab_size, use_bias=False)\n",
    "\n",
    "decoder = seq2seq.BasicDecoder(\n",
    "    decoder_cell, helper, decoder_initial_state,\n",
    "    output_layer=projection_layer)\n",
    "\n",
    "# Dynamic decoding\n",
    "# outputs.rnn_output   = plain output\n",
    "# outputs.sample_id = tf.argmax(outputs.rnn_output, axis=-1)\n",
    "outputs, final_context_state, _ = seq2seq.dynamic_decode(\n",
    "    decoder)\n",
    "\n",
    "logits_train = outputs.rnn_output\n",
    "prediction_train = outputs.sample_id\n",
    "\n",
    "\n",
    "### INFERENCE DECODER ###\n",
    "# Helper\n",
    "helper_infer = seq2seq.GreedyEmbeddingHelper(\n",
    "    embeddings,\n",
    "    tf.fill([batch_size], EOS), EOS)\n",
    "\n",
    "# Decoder\n",
    "decoder_infer = seq2seq.BasicDecoder(\n",
    "    decoder_cell, helper_infer, decoder_initial_state,\n",
    "    output_layer=projection_layer)\n",
    "\n",
    "# Dynamic decoding\n",
    "outputs_infer, final_context_state, final_seq_lengths = seq2seq.dynamic_decode(\n",
    "    decoder_infer,\n",
    "    impute_finished=True,\n",
    "#     maximum_iterations=tf.reduce_max(encoder_inputs_length) + add_output_length)\n",
    "    maximum_iterations=test_length)\n",
    "prediction_inference = tf.identity(outputs_infer.sample_id,\n",
    "                                   name='prediction_infer')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "targets = tf.transpose(decoder_train_targets, [1, 0])\n",
    "test_targets = tf.transpose(decoder_test_targets, [1, 0])\n",
    "## Loss\n",
    "loss = seq2seq.sequence_loss(logits=logits_train,\n",
    "                             targets=targets,\n",
    "                             weights=loss_weights,\n",
    "                             name='loss')\n",
    "\n",
    "## Calculate and clip gradients\n",
    "params = tf.trainable_variables()\n",
    "gradients = tf.gradients(loss, params)\n",
    "clipped_gradients, _ = tf.clip_by_global_norm(\n",
    "    gradients, max_gradient_norm)\n",
    "\n",
    "### Optimization\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate)\n",
    "train_step = optimizer.apply_gradients(\n",
    "    zip(clipped_gradients, params),\n",
    "    name='train_step')\n",
    "\n",
    "\n",
    "### Evaluate model\n",
    "# Pad prediction to match lengths\n",
    "prediction_infer_padded = tf.pad(\n",
    "    prediction_inference,\n",
    "    [[0, 0], [0, test_length - tf.reduce_max(final_seq_lengths)]],\n",
    "    mode='CONSTANT')\n",
    "\n",
    "correct_prediction = tf.equal(prediction_infer_padded,\n",
    "                              test_targets)\n",
    "## Advanced accuracy only the elements of seq including EOS symbol\n",
    "# accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "accuracy = tf.reduce_sum(tf.cast(correct_prediction, tf.float32)*test_weights)/tf.reduce_sum(test_weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to  previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overriden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"900\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "batch 0 - loss: 3.9249754\n",
      "    expected  > [ 3 28 38 32  1  0  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [28 28  1  0  0  0  0  0  0  0  0  0  0  0  0]\n",
      "    expected  > [35 42 31 41 42 47 28  1  0  0  0  0  0  0  0]\n",
      "    predicted > [28  1  0  0  0  0  0  0  0  0  0  0  0  0  0]\n",
      "\n",
      "batch 2000 - loss: 1.6534165\n",
      "    expected  > [43 48 39 39  1  0  0  0  0]\n",
      "    predicted > [43 28 39  1  0  0  0  0  0]\n",
      "    expected  > [20  1  0  0  0  0  0  0  0]\n",
      "    predicted > [12  1  0  0  0  0  0  0  0]\n",
      "\n",
      "batch 4000 - loss: 1.3383532\n",
      "    expected  > [40 36 46 47 42  1  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [49 28 46 47 42  1  0  0  0  0  0  0  0  0  0]\n",
      "    expected  > [38 45 28  1  0  0  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [47 45 28 40  1  0  0  0  0  0  0  0  0  0  0]\n",
      "\n",
      "batch 6000 - loss: 1.1780998\n",
      "    expected  > [53 39 48 47 28  1  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [30 39 28 47 28  1  0  0  0  0  0  0  0  0  0]\n",
      "    expected  > [47 36 40 32  1  0  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [38 45 42 49 32  1  0  0  0  0  0  0  0  0  0]\n",
      "\n",
      "batch 8000 - loss: 1.1226385\n",
      "    expected  > [ 3 45 32 47 28  1  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [ 3 28 30 38  1  0  0  0  0  0  0  0  0  0  0]\n",
      "    expected  > [21 49 28 45 48  1  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [27 28 45 36  1  0  0  0  0  0  0  0  0  0  0]\n",
      "\n",
      "batch 10000 - loss: 1.3133575\n",
      "    expected  > [13 28 31 36 46 39 28 49  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "    predicted > [ 3 28 30 35 42 30 39 42 49  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "    expected  > [16 46 28 40 32 39 28  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "    predicted > [16 45 30 41 36 38 36  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "\n",
      "batch 12000 - loss: 1.4228649\n",
      "    expected  > [12 42 41 47 36 41 32 41 47 28 39 41 36  1  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0]\n",
      "    predicted > [35 42 47 36 40 28 39 36  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0]\n",
      "    expected  > [49 52 53 38 48 40 41 32  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0]\n",
      "    predicted > [49 52 46 38 48 40 48 41 36  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0]\n",
      "\n",
      "batch 14000 - loss: 1.8237103\n",
      "    expected  > [52  1  0  0  0  0  0  0  0]\n",
      "    predicted > [23  1  0  0  0  0  0  0  0]\n",
      "    expected  > [45 32 28 39 39 52  1  0  0]\n",
      "    predicted > [40 28 39 39 52  1  0  0  0]\n",
      "\n",
      "batch 16000 - loss: 1.9093359\n",
      "    expected  > [34 28 34  1  0  0  0  0  0]\n",
      "    predicted > [40 48 52  1  0  0  0  0  0]\n",
      "    expected  > [45 52 46  1  0  0  0  0  0]\n",
      "    predicted > [40 52 37  1  0  0  0  0  0]\n",
      "\n",
      "batch 18000 - loss: 1.6860849\n",
      "    expected  > [48 49 32 46 47  1  0  0  0  0  0  0  0]\n",
      "    predicted > [40 42 53 32 47  1  0  0  0  0  0  0  0]\n",
      "    expected  > [43 32 41  1  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [43 28 45  1  0  0  0  0  0  0  0  0  0]\n",
      "\n",
      "Training interrupted, model saved.\n"
     ]
    }
   ],
   "source": [
    "sess = tf.InteractiveSession()\n",
    "sess.run(tf.global_variables_initializer())\n",
    "saver = tf.train.Saver()\n",
    "\n",
    "# Creat plot for live stats ploting\n",
    "trainPlot = TrainingPlot(TRAIN_STEPS, TEST_ITER, LOSS_ITER)\n",
    "\n",
    "try:\n",
    "    for i_batch in range(TRAIN_STEPS):\n",
    "        fd = train_iterator.next_feed(BATCH_SIZE)\n",
    "        train_step.run(fd)\n",
    "        \n",
    "        if i_batch % LOSS_ITER == 0:\n",
    "            # Plotting loss\n",
    "            tmpLoss = loss.eval(fd)\n",
    "            trainPlot.updateCost(tmpLoss, i_batch // LOSS_ITER)\n",
    "    \n",
    "        if i_batch % TEST_ITER == 0:\n",
    "            # Plotting accuracy\n",
    "            fd_test = test_iterator.next_feed(BATCH_SIZE)\n",
    "            accTest = accuracy.eval(fd_test)\n",
    "            accTrain = accuracy.eval(fd)\n",
    "            trainPlot.updateAcc(accTest, accTrain, i_batch // TEST_ITER)\n",
    "\n",
    "        if i_batch % SAVE_ITER == 0:\n",
    "            saver.save(sess, save_location)\n",
    "        \n",
    "        if i_batch % EPOCH == 0:\n",
    "            fd_test = test_iterator.next_feed(BATCH_SIZE)\n",
    "            print('batch %r - loss: %r' % (i_batch, sess.run(loss, fd_test)))\n",
    "            predict_, target_ = sess.run([prediction_infer_padded, test_targets], fd_test)\n",
    "            for i, (inp, pred) in enumerate(zip(target_, predict_)):\n",
    "                print('    expected  > {}'.format(inp))\n",
    "                print('    predicted > {}'.format(pred))\n",
    "                if i >= 1:\n",
    "                    break\n",
    "            print()\n",
    "\n",
    "except KeyboardInterrupt:\n",
    "    saver.save(sess, save_location)\n",
    "    print('Training interrupted, model saved.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    expected  > [4 1 0 0 0 0 0 0 0]\n",
      "    predicted > [4 1 0 0 0 0 0 0 0]\n",
      "    expected  > [42 29 32 37 31 32 47 32  1]\n",
      "    predicted > [31 52 47 32 47  1  0  0  0]\n",
      "\n",
      "    expected  > [53 28 43 39 28 47 28  1  0  0  0  0  0  0  0]\n",
      "    predicted > [31 28 46 39 48 47 28  1  0  0  0  0  0  0  0]\n",
      "    expected  > [40 36 30  1  0  0  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [41 36 53  1  0  0  0  0  0  0  0  0  0  0  0]\n",
      "\n",
      "    expected  > [49 52 53 38 48 40 41 32  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "    predicted > [49 52 53 38 48 40 48  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "    expected  > [29 39 36 53 38 42  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "    predicted > [29 39 28 30 38 28  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "\n",
      "    expected  > [45 42 38  1  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [45 42 38  1  0  0  0  0  0  0  0  0  0]\n",
      "    expected  > [45 28 31  1  0  0  0  0  0  0  0  0  0]\n",
      "    predicted > [45 28 31  1  0  0  0  0  0  0  0  0  0]\n",
      "\n",
      "    expected  > [47 32 45 30 32 40  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "    predicted > [47 45 32 30 32 41  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "    expected  > [46 36 41 30 32  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "    predicted > [48 36 41 30 32  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0\n",
      "  0  0  0  0  0  0  0]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    fd_test = test_iterator.next_feed(BATCH_SIZE)\n",
    "    predict_, target_ = sess.run([prediction_infer_padded, test_targets], fd_test)\n",
    "    for i, (inp, pred) in enumerate(zip(target_, predict_)):\n",
    "        print('    expected  > {}'.format(inp))\n",
    "        print('    predicted > {}'.format(pred))\n",
    "        if i >= 1:\n",
    "            break\n",
    "    print()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}