char_segmentation_BiRNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Training: CNN with Bidirctional RNN - Character Segmentation\n",
    "Training model combining CNN with bidirectional RNN for character segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "autoscroll": false,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import tensorflow as tf\n",
    "import cv2\n",
    "\n",
    "sys.path.append('src')\n",
    "from ocr.helpers import implt\n",
    "from ocr.mlhelpers import TrainingPlot\n",
    "from ocr.datahelpers import load_words_data, corresponding_shuffle\n",
    "from ocr.tfhelpers import create_cell\n",
    "\n",
    "\n",
    "%matplotlib notebook\n",
    "plt.rcParams['figure.figsize'] = (9.0, 5.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "autoscroll": false,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "PAD = 0                            # Value for PADding images\n",
    "POS = 1                            # Values of positive and negative label 0/-1\n",
    "NEG = 0\n",
    "\n",
    "POS_SPAN = 1                             # Number of positive values around true position (5 is too high)\n",
    "POS_WEIGHT = 3                           # Weighting possitive values in loss counting\n",
    "\n",
    "slider_size = (60, 60)                   # Height is set to 60 by data and width should be even\n",
    "slider_step = 2\n",
    "N_INPUT = slider_size[0]*slider_size[1]  # Size of sequence input vector will depend on CNN\n",
    "num_buckets = 5\n",
    "n_classes = 2                            # Number of different outputs\n",
    "\n",
    "rnn_layers = 4\n",
    "rnn_residual_layers = 2                  # HAVE TO be smaller than encoder_layers\n",
    "rnn_units = 256\n",
    "\n",
    "learning_rate = 1e-4\n",
    "dropout = 0.4                            # Percentage of dopped out data\n",
    "train_set = 0.8                          # Percentage of training data\n",
    "\n",
    "TRAIN_STEPS = 500000                     # Number of training steps!\n",
    "TEST_ITER = 150\n",
    "LOSS_ITER = 50\n",
    "SAVE_ITER = 2000\n",
    "BATCH_SIZE = 10\n",
    "# EPOCH = 2000                           # \"Number\" of batches in epoch\n",
    "\n",
    "save_loc = 'models/gap-clas/RNN/Bi-RNN-new'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Loading Images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "autoscroll": false,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading words...\n",
      " |████████████████████████████████████████| 100.0% \n",
      "-> Number of words: 5069\n"
     ]
    }
   ],
   "source": [
    "images, _, gaplines = load_words_data(\n",
    "    ['data/processed/breta/words_gaplines/'],\n",
    "    load_gaplines=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training images: 4055\n",
      "Testing images: 1014\n"
     ]
    }
   ],
   "source": [
    "# Shuffle data\n",
    "images, gaplines = corresponding_shuffle([images, gaplines])\n",
    "\n",
    "for i in range(len(images)):\n",
    "    # Add border and offset gaplines - RUN ONLY ONCE\n",
    "    images[i] = cv2.copyMakeBorder(images[i],\n",
    "                                   0, 0, int(slider_size[1]/2), int(slider_size[1]/2),\n",
    "                                   cv2.BORDER_CONSTANT,\n",
    "                                   value=0)\n",
    "    gaplines[i] += int(slider_size[1] / 2)\n",
    "    \n",
    "# Split data on train and test dataset\n",
    "div = int(train_set * len(images))\n",
    "\n",
    "trainImages = images[0:div]\n",
    "testImages = images[div:]\n",
    "\n",
    "trainGaplines = gaplines[0:div]\n",
    "testGaplines = gaplines[div:]\n",
    "\n",
    "print(\"Training images:\", div)\n",
    "print(\"Testing images:\", len(images) - div)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BucketDataIterator():\n",
    "    \"\"\" Iterator for feeding seq2seq model during training \"\"\"\n",
    "    def __init__(self,\n",
    "                 images,\n",
    "                 gaplines,\n",
    "                 gap_span,\n",
    "                 num_buckets=5,\n",
    "                 slider=(60, 30),\n",
    "                 slider_step=2,\n",
    "                 imgprocess=lambda x: x,\n",
    "                 train=True):\n",
    "        \n",
    "        self.train = train\n",
    "        length = [(image.shape[1]-slider[1])//slider_step for image in images]\n",
    "    \n",
    "        # Creating indices from gaplines\n",
    "        indices = gaplines - int(slider[1]/2)\n",
    "        indices = indices // slider_step\n",
    "        \n",
    "        # Split images to sequence of vectors\n",
    "        # + targets seq of labels per image in images seq\n",
    "        images_seq = np.empty(len(images), dtype=object)\n",
    "        targets_seq = np.empty(len(images), dtype=object)\n",
    "        for i, img in enumerate(images):\n",
    "            images_seq[i] = [imgprocess(img[:, loc * slider_step: loc * slider_step + slider[1]].flatten())\n",
    "                             for loc in range(length[i])]\n",
    "            \n",
    "            targets_seq[i] = np.ones((length[i])) * NEG\n",
    "            for offset in range(gap_span):\n",
    "                ind = indices[i] + (-(offset % 2) * offset // 2) + ((1 - offset%2) * offset // 2) \n",
    "                \n",
    "                if ind[0] < 0:\n",
    "                    ind[0] = 0\n",
    "                if ind[-1] >= length[i]:\n",
    "                    ind[-1] = length[i] - 1\n",
    "                    \n",
    "                targets_seq[i][ind] = POS  \n",
    "\n",
    "        # Create pandas dataFrame and sort it by images seq lenght (length) \n",
    "        # in_length == out_length\n",
    "        self.dataFrame = pd.DataFrame({'length': length,\n",
    "                                       'images': images_seq,\n",
    "                                       'targets': targets_seq\n",
    "                                      }).sort_values('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",
    "\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, 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",
    "        max_length = max(res['length'])\n",
    "        \n",
    "        input_seq = np.zeros((batch_size, max_length, N_INPUT), dtype=np.float32)\n",
    "        for i, img in enumerate(res['images']):\n",
    "            input_seq[i][:res['length'].values[i]] = img\n",
    "        \n",
    "        # Need to pad according to the maximum length output sequence\n",
    "        targets = np.ones([batch_size, max_length], dtype=np.float32) * PAD\n",
    "        for i, target in enumerate(targets):\n",
    "            target[:res['length'].values[i]] = res['targets'].values[i]\n",
    "        \n",
    "        return input_seq, targets, res['length'].values\n",
    "\n",
    "\n",
    "    def next_feed(self, size):\n",
    "        \"\"\" Create feed directly for model training \"\"\"\n",
    "        (inputs_,\n",
    "         targets_,\n",
    "         length_) = self.next_batch(size)\n",
    "        return {\n",
    "            inputs: inputs_,            \n",
    "            targets: targets_,\n",
    "            length: length_,\n",
    "            keep_prob: (1.0 - dropout) if self.train else 1.0\n",
    "        }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iterator created.\n",
      "Iterator created.\n"
     ]
    }
   ],
   "source": [
    "# Create iterator for feeding BiRNN\n",
    "train_iterator = BucketDataIterator(trainImages,\n",
    "                                    trainGaplines,\n",
    "                                    POS_SPAN,\n",
    "                                    num_buckets,\n",
    "                                    slider_size,\n",
    "                                    slider_step,\n",
    "                                    train=True)\n",
    "test_iterator = BucketDataIterator(testImages,\n",
    "                                   testGaplines,\n",
    "                                   POS_SPAN,\n",
    "                                   1,\n",
    "                                   slider_size,\n",
    "                                   slider_step,\n",
    "                                   train=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Create classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "autoscroll": false,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Input placehodlers\n",
    "# N_INPUT -> size of vector representing one image in sequence\n",
    "# Inputs shape (batch_size, max_seq_length, vec_size) - time major\n",
    "inputs = tf.placeholder(shape=(None, None, N_INPUT),\n",
    "                                dtype=tf.float32,\n",
    "                                name='inputs')\n",
    "length = tf.placeholder(shape=(None,),\n",
    "                        dtype=tf.int32,\n",
    "                        name='length')\n",
    "# Required for training, not required for application\n",
    "targets = tf.placeholder(shape=(None, None),\n",
    "                         dtype=tf.int64,\n",
    "                         name='targets')\n",
    "# Dropout value\n",
    "keep_prob = tf.placeholder(tf.float32, name='keep_prob')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Standardization + CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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, 2],\n",
    "                          initializer=tf.contrib.layers.xavier_initializer())\n",
    "b_conv1 = tf.Variable(tf.constant(0.1, shape=[2]), name='b_conv1')\n",
    "# 3. Layer - Convulation variables\n",
    "W_conv2 = tf.get_variable('W_conv2', shape=[5, 5, 2, 4],\n",
    "                          initializer=tf.contrib.layers.xavier_initializer())\n",
    "b_conv2 = tf.Variable(tf.constant(0.1, shape=[4]), name='b_conv2')\n",
    "\n",
    "def CNN(x):\n",
    "    x = tf.image.per_image_standardization(x)\n",
    "    x = tf.reshape(x, [1, slider_size[0], slider_size[1], 1])\n",
    "    # 1. Layer - Convulation\n",
    "    h_conv1 = tf.nn.relu(conv2d(x, 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",
    "inpts = 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])),\n",
    "#                 CNN(tf.reshape(img, [1, slider_size[0], slider_size[1], 1])),\n",
    "                [-1]),\n",
    "        seq),\n",
    "    inputs,\n",
    "    dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bi-RNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cells\n",
    "cell_fw = create_cell(rnn_units,\n",
    "                      rnn_layers,\n",
    "                      rnn_residual_layers,\n",
    "                      is_dropout=True,\n",
    "                      keep_prob=keep_prob)\n",
    "cell_bw = create_cell(rnn_units,\n",
    "                      rnn_layers,\n",
    "                      rnn_residual_layers,\n",
    "                      is_dropout=True,\n",
    "                      keep_prob=keep_prob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bidirectional RNN\n",
    "bi_outputs, _ = tf.nn.bidirectional_dynamic_rnn(\n",
    "    cell_fw = cell_fw,\n",
    "    cell_bw = cell_bw,\n",
    "    inputs = inpts,\n",
    "    sequence_length = length,\n",
    "    dtype = tf.float32)\n",
    "\n",
    "outputs = tf.concat(bi_outputs, -1, name='outputs')\n",
    "\n",
    "# pred = tf.matmul(outputs, W)\n",
    "# pred = tf.scan(lambda a, x: tf.matmul(x, W), outputs, infer_shape=False)\n",
    "pred = tf.layers.dense(inputs=outputs,\n",
    "                       units=n_classes,\n",
    "                       name='pred')\n",
    "prediction = tf.argmax(pred, axis=-1, name='prediction')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define loss and optimizer\n",
    "weights = tf.multiply(targets, POS_WEIGHT) + 1\n",
    "loss = tf.reduce_mean(tf.losses.sparse_softmax_cross_entropy(\n",
    "    logits=pred,\n",
    "    labels=targets,\n",
    "    weights=weights), name='loss')\n",
    "train_step = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss, name='train_step')\n",
    "\n",
    "# Evaluate model\n",
    "correct_pred = tf.equal(prediction, targets)\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "autoscroll": false,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "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": [
      "Training interrupted, model saved.\n",
      "Training finished with accuracy: 0.975385\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_loc)\n",
    "        \n",
    "except KeyboardInterrupt:\n",
    "    saver.save(sess, save_loc)\n",
    "    print('Training interrupted, model saved.')\n",
    "\n",
    "\n",
    "fd_test = test_iterator.next_feed(2*BATCH_SIZE)\n",
    "accTest = accuracy.eval(fd_test)\n",
    "print(\"Training finished with accuracy:\", accTest)"
   ]
  }
 ],
 "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"
  },
  "name": "CharClassifier-BiRNN.ipynb"
 },
 "nbformat": 4,
 "nbformat_minor": 1
}