char_classifier_RNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Training: BiRNN - Character Classifier\n",
    "Training bidirectional RNN (recurrent neural network) for char classification"
   ]
  },
  {
   "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 tensorflow as tf\n",
    "import cv2\n",
    "import random\n",
    "import unidecode\n",
    "\n",
    "sys.path.append('src')\n",
    "from ocr.datahelpers import load_chars_data, corresponding_shuffle, char2idx\n",
    "from ocr.helpers import implt\n",
    "from ocr.mlhelpers import TrainingPlot\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": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "### Global Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "autoscroll": false,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "LANG = 'en'\n",
    "\n",
    "PAD = 0                            # Value for PADding images\n",
    "EOS = 1                            # Value for End Of Sequence (not in use)\n",
    "\n",
    "N_INPUT = 4096                     # Size of sequence input vector will depend on CNN\n",
    "num_buckets = 10\n",
    "CLAS = 83 if LANG =='cz' else 53   # 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               # 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\n",
    "TEST_ITER = 150\n",
    "LOSS_ITER = 50\n",
    "SAVE_ITER = 2000\n",
    "BATCH_SIZE = 64\n",
    "EPOCH = 2000\n",
    "\n",
    "save_loc = 'models/char-clas/' + LANG + '/Bi-RNN/model'\n",
    "summaries_dir = 'logs/char-clas-RNN'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Load Images and Lables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading chars...\n",
      "Loading words...\n",
      " |████████████████████████████████████████| 100.0% \n",
      "-> Number of words: 5069\n",
      "Loaded chars from words: 22883\n",
      " |████████████████████████████████████████| 100.0% \n",
      "-> Number of chars: 22883\n"
     ]
    }
   ],
   "source": [
    "images, labels = load_chars_data(\n",
    "    charloc='',\n",
    "    wordloc='data/processed/breta/words_gaplines/',\n",
    "    lang=LANG)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of words: 199988\n"
     ]
    }
   ],
   "source": [
    "# Extending dataset by inserting zero chars\n",
    "def random_insert(lst):\n",
    "    rand = random.randint(1, 3)\n",
    "    inserts = random.sample(range(len(lst) + rand), rand)\n",
    "    input = iter(lst)\n",
    "    res = [0 if pos in inserts else next(input)\n",
    "           for pos in range(len(lst) + rand)]\n",
    "    return res\n",
    "\n",
    "# Load Words\n",
    "tmpWords = []\n",
    "with open('data/dictionaries/' + LANG + '_50k.txt') as f:\n",
    "    for line in f:\n",
    "        tmpWords.append(unidecode.unidecode(line.split(\" \")[0]))\n",
    "\n",
    "length = len(tmpWords)\n",
    "words = np.empty(4*length, dtype=object)\n",
    "for i, word in enumerate(tmpWords):\n",
    "    try:\n",
    "        words[i] = [char2idx(c) for c in list(word)]\n",
    "        words[i + length] = [char2idx(c) for c in list(word.title())]\n",
    "        words[i + 2*length] = random_insert(words[i])\n",
    "        words[i + 3*length] = random_insert(words[i + length])\n",
    "    except KeyError:\n",
    "        print(i)\n",
    "        \n",
    "\n",
    "del tmpWords\n",
    "\n",
    "print(\"Number of words:\", len(words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training words: 159990\n"
     ]
    }
   ],
   "source": [
    "# Create images sequences corresponding to the words\n",
    "class charFeed:\n",
    "    def __init__(self, clas, letters):\n",
    "        self.cnt = np.zeros(clas, dtype=np.int32)\n",
    "        self.letters = letters\n",
    "        \n",
    "    def getChar(self, i):\n",
    "        if not self.cnt[i] < len(self.letters[i]):\n",
    "            random.shuffle(self.letters[i])\n",
    "            self.cnt[i] = 0\n",
    "            \n",
    "        self.cnt[i] += 1\n",
    "        return self.letters[i][self.cnt[i] - 1]\n",
    "    \n",
    "    def getLen(self, i):\n",
    "        return len(self.letters[i])\n",
    "\n",
    "\n",
    "# Separate images in such a way that there is each letter at leas once (in train and test set)\n",
    "images, labels = corresponding_shuffle([images, labels])\n",
    "\n",
    "letters = np.empty(CLAS, dtype=object)\n",
    "for i in range(CLAS):\n",
    "    letters[i] = []\n",
    "for i in range(len(images)):\n",
    "    letters[labels[i]].append(images[i])\n",
    "    \n",
    "trImages = []\n",
    "teImages = []\n",
    "trLabels = []\n",
    "teLabels= []\n",
    "\n",
    "feeder = charFeed(CLAS, letters)\n",
    "for i in range(CLAS):\n",
    "    for x in range(feeder.getLen(i)):\n",
    "        if x % 12 == 0:\n",
    "            teImages.append(feeder.getChar(i))\n",
    "            teLabels.append(i)\n",
    "        else:\n",
    "            trImages.append(feeder.getChar(i))\n",
    "            trLabels.append(i)\n",
    "            \n",
    "assert all((i in trLabels and i in teLabels) for i in range(CLAS))\n",
    "\n",
    "\n",
    "np.random.shuffle(words)\n",
    "div = int(train_set * len(words))\n",
    "trainLabels = words[0:div]\n",
    "testLabels = words[div:]\n",
    "del words\n",
    "        \n",
    "trLetters = np.empty(CLAS, dtype=object)\n",
    "teLetters = np.empty(CLAS, dtype=object)\n",
    "for i in range(CLAS):\n",
    "    trLetters[i] = []\n",
    "    teLetters[i] = []\n",
    "for i in range(len(trImages)):\n",
    "    trLetters[trLabels[i]].append(trImages[i])\n",
    "for i in range(len(teImages)):\n",
    "    teLetters[teLabels[i]].append(teImages[i])\n",
    "    \n",
    "    \n",
    "trFeeder = charFeed(CLAS, trLetters)\n",
    "trainData = np.empty(len(trainLabels), dtype=object)\n",
    "for i, word in enumerate(trainLabels):\n",
    "    trainData[i] = [trFeeder.getChar(c) for c in word]\n",
    "    \n",
    "teFeeder = charFeed(CLAS, teLetters)\n",
    "testData = np.empty(len(testLabels), dtype=object)\n",
    "for i, word in enumerate(testLabels):\n",
    "    testData[i] = [teFeeder.getChar(c) for c in word]\n",
    "    \n",
    "print(\"Training words: %g\" % div)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "autoscroll": false,
    "collapsed": true,
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class BucketDataIterator():\n",
    "    \"\"\" Iterator for feeding seq2seq model during training \"\"\"\n",
    "    def __init__(self,\n",
    "                 images_seq,\n",
    "                 targets_seq,\n",
    "                 num_buckets=5,\n",
    "                 train=True):\n",
    "        \n",
    "        self.train = train\n",
    "        length = [len(seq) for seq in images_seq]                \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,\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",
    "        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": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iterator created.\n",
      "Iterator created.\n"
     ]
    }
   ],
   "source": [
    "# Create iterators for data feeding\n",
    "train_iterator = BucketDataIterator(trainData,\n",
    "                                    trainLabels,\n",
    "                                    num_buckets,\n",
    "                                    train=True)\n",
    "valid_iterator = BucketDataIterator(testData,\n",
    "                                    testLabels,\n",
    "                                    5,\n",
    "                                    train=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ein.tags": "worksheet-0",
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "## Inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Input placehodlers\n",
    "# N_INPUT -> size of vector representing one image in sequence\n",
    "# Inputs shape (max_seq_length, batch_size, 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 testing and 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": [
    "## CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "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, 8],\n",
    "                          initializer=tf.contrib.layers.xavier_initializer())\n",
    "b_conv1 = tf.Variable(tf.constant(0.1, shape=[8]), name='b_conv1')\n",
    "# 3. Layer - Convulation variables\n",
    "W_conv2 = tf.get_variable('W_conv2', shape=[5, 5, 8, 16],\n",
    "                          initializer=tf.contrib.layers.xavier_initializer())\n",
    "b_conv2 = tf.Variable(tf.constant(0.1, shape=[16]), name='b_conv2')\n",
    "\n",
    "def CNN(x):\n",
    "    x = tf.reshape(x, [1, 64, 64, 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(img),\n",
    "                [-1]),\n",
    "        seq),\n",
    "    inputs,\n",
    "    dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bi-RNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "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": 11,
   "metadata": {
    "collapsed": true
   },
   "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=CLAS,\n",
    "                       name='pred')\n",
    "prediction = tf.argmax(pred, axis=-1, name='prediction')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define loss and optimizer\n",
    "loss = tf.reduce_mean(tf.losses.sparse_softmax_cross_entropy(logits=pred, labels=targets),\n",
    "                      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": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "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",
       "        this.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",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\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.9829605\n",
      "    expected  > [45 27 44 31 31]\n",
      "    predicted > [28 20 36 20 20]\n",
      "\n",
      "batch 2000 - loss: 0.29983974\n",
      "    expected  > [27 42 46 38 51]\n",
      "    predicted > [27 42 46 38 51]\n",
      "\n",
      "batch 4000 - loss: 0.069107354\n",
      "    expected  > [44 27  0 29 34]\n",
      "    predicted > [44 27  0 29 34]\n",
      "\n",
      "Training interrupted, model saved.\n",
      "Training finished with accuracy: 0.982813\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'models/char-clas/en/Bi-RNN/model_1'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sess = tf.InteractiveSession()\n",
    "# TensorBoard\n",
    "tf.summary.scalar('Loss', loss)\n",
    "tf.summary.scalar('Accuracy', accuracy)\n",
    "merged = tf.summary.merge_all()\n",
    "\n",
    "train_writer = tf.summary.FileWriter(\n",
    "    summaries_dir + '/train', sess.graph)\n",
    "test_writer = tf.summary.FileWriter(\n",
    "    summaries_dir + '/test')\n",
    "\n",
    "\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_valid = valid_iterator.next_feed(BATCH_SIZE)\n",
    "                \n",
    "            accTest, teSum = sess.run([accuracy, merged], feed_dict=fd_valid)\n",
    "            accTrain, trSum = sess.run([accuracy, merged], feed_dict=fd)\n",
    "                \n",
    "            trainPlot.updateAcc(accTest, accTrain, i_batch // TEST_ITER)\n",
    "            test_writer.add_summary(teSum, i_batch)\n",
    "            train_writer.add_summary(trSum, i_batch)\n",
    "\n",
    "        if i_batch % SAVE_ITER == 0:\n",
    "            saver.save(sess, save_loc)\n",
    "        \n",
    "        if i_batch % EPOCH == 0:\n",
    "            fd_valid = valid_iterator.next_feed(BATCH_SIZE)\n",
    "            print('batch %r - loss: %r' % (i_batch, sess.run(loss, fd_valid)))\n",
    "            predict_, target_ = sess.run([prediction, targets], fd_valid)\n",
    "            for i, (inp, pred) in enumerate(zip(target_, predict_)):\n",
    "                print('    expected  > {}'.format(inp))\n",
    "                print('    predicted > {}'.format(pred))\n",
    "                break\n",
    "            print()\n",
    "\n",
    "except KeyboardInterrupt:\n",
    "    saver.save(sess, save_loc)\n",
    "    print('Training interrupted, model saved.')\n",
    "\n",
    "\n",
    "acc_val = accuracy.eval(valid_iterator.next_feed(2*BATCH_SIZE))\n",
    "print(\"Training finished with accuracy:\", acc_val)\n",
    "saver.save(sess, save_loc)"
   ]
  }
 ],
 "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.ipynb"
 },
 "nbformat": 4,
 "nbformat_minor": 1
}