4_convolutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4embtkV0pNxM"
   },
   "source": [
    "Deep Learning\n",
    "=============\n",
    "\n",
    "Assignment 4\n",
    "------------\n",
    "\n",
    "Previously in `2_fullyconnected.ipynb` and `3_regularization.ipynb`, we trained fully connected networks to classify [notMNIST](http://yaroslavvb.blogspot.com/2011/09/notmnist-dataset.html) characters.\n",
    "\n",
    "The goal of this assignment is make the neural network convolutional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "tm2CQN_Cpwj0"
   },
   "outputs": [],
   "source": [
    "# These are all the modules we'll be using later. Make sure you can import them\n",
    "# before proceeding further.\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from six.moves import cPickle as pickle\n",
    "from six.moves import range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "collapsed": false,
    "executionInfo": {
     "elapsed": 11948,
     "status": "ok",
     "timestamp": 1446658914837,
     "user": {
      "color": "",
      "displayName": "",
      "isAnonymous": false,
      "isMe": true,
      "permissionId": "",
      "photoUrl": "",
      "sessionId": "0",
      "userId": ""
     },
     "user_tz": 480
    },
    "id": "y3-cj1bpmuxc",
    "outputId": "016b1a51-0290-4b08-efdb-8c95ffc3cd01"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Training set', (300000, 28, 28), (300000,))\n",
      "('Validation set', (18724, 28, 28), (18724,))\n",
      "('Test set', (18724, 28, 28), (18724,))\n"
     ]
    }
   ],
   "source": [
    "pickle_file = 'notMNIST.pickle'\n",
    "\n",
    "with open(pickle_file, 'rb') as f:\n",
    "  save = pickle.load(f)\n",
    "  train_dataset = save['train_dataset']\n",
    "  train_labels = save['train_labels']\n",
    "  valid_dataset = save['valid_dataset']\n",
    "  valid_labels = save['valid_labels']\n",
    "  test_dataset = save['test_dataset']\n",
    "  test_labels = save['test_labels']\n",
    "  del save  # hint to help gc free up memory\n",
    "    \n",
    "  #trim validation dataset (maybe we use it for cross validation later)\n",
    "  valid_dataset = valid_dataset[:18724,:,:]\n",
    "  valid_labels = valid_labels[:18724]\n",
    "    \n",
    "  print('Training set', train_dataset.shape, train_labels.shape)\n",
    "  print('Validation set', valid_dataset.shape, valid_labels.shape)\n",
    "  print('Test set', test_dataset.shape, test_labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L7aHrm6nGDMB"
   },
   "source": [
    "Reformat into a TensorFlow-friendly shape:\n",
    "- convolutions need the image data formatted as a cube (width by height by #channels)\n",
    "- labels as float 1-hot encodings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "collapsed": false,
    "executionInfo": {
     "elapsed": 11952,
     "status": "ok",
     "timestamp": 1446658914857,
     "user": {
      "color": "",
      "displayName": "",
      "isAnonymous": false,
      "isMe": true,
      "permissionId": "",
      "photoUrl": "",
      "sessionId": "0",
      "userId": ""
     },
     "user_tz": 480
    },
    "id": "IRSyYiIIGIzS",
    "outputId": "650a208c-8359-4852-f4f5-8bf10e80ef6c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Training set', (300000, 28, 28, 1), (300000, 10))\n",
      "('Validation set', (18724, 28, 28, 1), (18724, 10))\n",
      "('Test set', (18724, 28, 28, 1), (18724, 10))\n"
     ]
    }
   ],
   "source": [
    "image_size = 28\n",
    "num_labels = 10\n",
    "num_channels = 1 # grayscale\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "def reformat(dataset, labels):\n",
    "  dataset = dataset.reshape(\n",
    "    (-1, image_size, image_size, num_channels)).astype(np.float32)\n",
    "  labels = (np.arange(num_labels) == labels[:,None]).astype(np.float32)\n",
    "  return dataset, labels\n",
    "train_dataset, train_labels = reformat(train_dataset, train_labels)\n",
    "valid_dataset, valid_labels = reformat(valid_dataset, valid_labels)\n",
    "test_dataset, test_labels = reformat(test_dataset, test_labels)\n",
    "print('Training set', train_dataset.shape, train_labels.shape)\n",
    "print('Validation set', valid_dataset.shape, valid_labels.shape)\n",
    "print('Test set', test_dataset.shape, test_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "AgQDIREv02p1"
   },
   "outputs": [],
   "source": [
    "def accuracy(predictions, labels):\n",
    "  return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1))\n",
    "          / predictions.shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "5rhgjmROXu2O"
   },
   "source": [
    "Let's build a small network with two convolutional layers, followed by one fully connected layer. Convolutional networks are more expensive computationally, so we'll limit its depth and number of fully connected nodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "collapsed": true,
    "id": "IZYv70SvvOan"
   },
   "outputs": [],
   "source": [
    "batch_size = 16\n",
    "patch_size = 5\n",
    "depth = 16\n",
    "num_hidden = 64\n",
    "\n",
    "graph = tf.Graph()\n",
    "\n",
    "with graph.as_default():\n",
    "\n",
    "  # Input data.\n",
    "  tf_train_dataset = tf.placeholder(\n",
    "    tf.float32, shape=(batch_size, image_size, image_size, num_channels))\n",
    "  tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))\n",
    "  tf_valid_dataset = tf.constant(valid_dataset)\n",
    "  tf_test_dataset = tf.constant(test_dataset)\n",
    "  \n",
    "  # Variables.\n",
    "  layer1_weights = tf.Variable(tf.truncated_normal(\n",
    "      [patch_size, patch_size, num_channels, depth], stddev=0.1))\n",
    "  layer1_biases = tf.Variable(tf.zeros([depth]))\n",
    "  layer2_weights = tf.Variable(tf.truncated_normal(\n",
    "      [patch_size, patch_size, depth, depth], stddev=0.1))\n",
    "  layer2_biases = tf.Variable(tf.constant(1.0, shape=[depth]))\n",
    "  layer3_weights = tf.Variable(tf.truncated_normal(\n",
    "      [image_size / 4 * image_size / 4 * depth, num_hidden], stddev=0.1))\n",
    "  layer3_biases = tf.Variable(tf.constant(1.0, shape=[num_hidden]))\n",
    "  layer4_weights = tf.Variable(tf.truncated_normal(\n",
    "      [num_hidden, num_labels], stddev=0.1))\n",
    "  layer4_biases = tf.Variable(tf.constant(1.0, shape=[num_labels]))\n",
    "  \n",
    "  # Model.\n",
    "  def model(data):\n",
    "    conv = tf.nn.conv2d(data, layer1_weights, [1, 2, 2, 1], padding='SAME')\n",
    "    hidden = tf.nn.relu(conv + layer1_biases)\n",
    "    conv = tf.nn.conv2d(hidden, layer2_weights, [1, 2, 2, 1], padding='SAME')\n",
    "    hidden = tf.nn.relu(conv + layer2_biases)\n",
    "    shape = hidden.get_shape().as_list()\n",
    "    reshape = tf.reshape(hidden, [shape[0], shape[1] * shape[2] * shape[3]])\n",
    "    hidden = tf.nn.relu(tf.matmul(reshape, layer3_weights) + layer3_biases)\n",
    "    return tf.matmul(hidden, layer4_weights) + layer4_biases\n",
    "  \n",
    "  # Training computation.\n",
    "  logits = model(tf_train_dataset)\n",
    "  loss = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels))\n",
    "    \n",
    "  # Optimizer.\n",
    "  optimizer = tf.train.GradientDescentOptimizer(0.05).minimize(loss)\n",
    "  \n",
    "  # Predictions for the training, validation, and test data.\n",
    "  train_prediction = tf.nn.softmax(logits)\n",
    "  valid_prediction = tf.nn.softmax(model(tf_valid_dataset))\n",
    "  test_prediction = tf.nn.softmax(model(tf_test_dataset))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cellView": "both",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "output_extras": [
      {
       "item_id": 37
      }
     ]
    },
    "colab_type": "code",
    "collapsed": false,
    "executionInfo": {
     "elapsed": 63292,
     "status": "ok",
     "timestamp": 1446658966251,
     "user": {
      "color": "",
      "displayName": "",
      "isAnonymous": false,
      "isMe": true,
      "permissionId": "",
      "photoUrl": "",
      "sessionId": "0",
      "userId": ""
     },
     "user_tz": 480
    },
    "id": "noKFb2UovVFR",
    "outputId": "28941338-2ef9-4088-8bd1-44295661e628"
   },
   "source": [
    "num_steps = 1001\n",
    "\n",
    "with tf.Session(graph=graph) as session:\n",
    "  tf.initialize_all_variables().run()\n",
    "  print('Initialized')\n",
    "  for step in range(num_steps):\n",
    "    offset = (step * batch_size) % (train_labels.shape[0] - batch_size)\n",
    "    batch_data = train_dataset[offset:(offset + batch_size), :, :, :]\n",
    "    batch_labels = train_labels[offset:(offset + batch_size), :]\n",
    "    feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels}\n",
    "    _, l, predictions = session.run(\n",
    "      [optimizer, loss, train_prediction], feed_dict=feed_dict)\n",
    "    if (step % 50 == 0):\n",
    "      print('Minibatch loss at step %d: %f' % (step, l))\n",
    "      print('Minibatch accuracy: %.1f%%' % accuracy(predictions, batch_labels))\n",
    "      print('Validation accuracy: %.1f%%' % accuracy(\n",
    "        valid_prediction.eval(), valid_labels))\n",
    "  print('Test accuracy: %.1f%%' % accuracy(test_prediction.eval(), test_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def weight_variable(shape, prev_n_count=2, name=None):\n",
    "    initial = tf.truncated_normal(shape, stddev=math.sqrt(2.0/prev_n_count))\n",
    "    #initial = tf.truncated_normal(shape)\n",
    "    return tf.Variable(initial, name)\n",
    "\n",
    "def bias_variable(shape, name=None):\n",
    "    initial = tf.constant(0.0, shape=shape)\n",
    "    return tf.Variable(initial, name)\n",
    "\n",
    "def train_model(num_steps, checkpoint_every, batch_size, graph, is_saving=False, keep_prob = 0.5, restore=False):\n",
    "    with tf.Session(graph=graph) as session:\n",
    "        if restore:\n",
    "            ckpt = tf.train.get_checkpoint_state('./')\n",
    "            #print ckpt\n",
    "            if ckpt and ckpt.model_checkpoint_path:                \n",
    "                filename = ckpt.model_checkpoint_path\n",
    "            saver.restore(session, filename)\n",
    "            print 'session restored from %s' % filename\n",
    "        else:\n",
    "            tf.initialize_all_variables().run()\n",
    "            print(\"Initialized\")\n",
    "        for step in range(num_steps):\n",
    "            # Pick an offset within the training data, which has been randomized.\n",
    "            # Note: we could use better randomization across epochs.\n",
    "            offset = (step * batch_size) % (train_labels.shape[0] - batch_size)\n",
    "            # Generate a minibatch.\n",
    "            batch_data = train_dataset[offset:(offset + batch_size), :]\n",
    "            batch_labels = train_labels[offset:(offset + batch_size), :]\n",
    "            # Prepare a dictionary telling the session where to feed the minibatch.\n",
    "            # The key of the dictionary is the placeholder node of the graph to be fed,\n",
    "            # and the value is the numpy array to feed to it.\n",
    "            feed_dict = {tf_train_dataset : batch_data, tf_train_labels : batch_labels,\n",
    "                         tf_batch_size: batch_size, tf_keep_prob: keep_prob}\n",
    "            _, l, lr = session.run([optimizer, loss, learning_rate], feed_dict=feed_dict)\n",
    "            if (step % checkpoint_every == 0):\n",
    "                print(\"Minibatch loss at step %d: %f with learning rate %f\" % (step, l, lr))\n",
    "                train_accuracy = accuracy_l.eval(feed_dict={tf_train_dataset:batch_data, tf_train_labels: batch_labels,\n",
    "                                                           tf_keep_prob: 1.0})\n",
    "                print \"step %d, training accuracy %g\" % (step, train_accuracy)                \n",
    "                print(\"Validation accuracy: %g\" %\n",
    "                    accuracy_l.eval(feed_dict={ tf_train_dataset: valid_dataset, tf_train_labels: valid_labels,\n",
    "                                              tf_keep_prob: 1.0}))\n",
    "                #save model\n",
    "                if(is_saving):\n",
    "                    saver.save(session, './model.ckpt', global_step=step)\n",
    "        print(\"test accuracy %g\" % \n",
    "              accuracy_l.eval(feed_dict={ tf_train_dataset: test_dataset,\n",
    "                                                              tf_train_labels: test_labels, tf_keep_prob: 1.0}))\n",
    "        \n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.gridspec as gridspec\n",
    "import random\n",
    "\n",
    "def predict_letter(image, session):\n",
    "    with session.as_default():\n",
    "        probs = y_conv.eval(feed_dict={ tf_train_dataset: [image], tf_train_labels: [[0,0,0,0,0,0,0,0,0,0]],\n",
    "                                      tf_keep_prob: 1.0})\n",
    "    #print probs\n",
    "    return tf.argmax(probs,1).eval() #return index of max value\n",
    "\n",
    "def find_incorrect(dataset, labels, session):\n",
    "    with session.as_default():\n",
    "        #tensor with True when prediction == label\n",
    "        correct_predicitons = is_correct_prediction.eval(feed_dict={ tf_train_dataset: dataset,\n",
    "                                                                    tf_train_labels: labels, tf_keep_prob: 1.0})\n",
    "    #return indexes of invalid\n",
    "    return np.where(correct_predicitons == False)\n",
    "    \n",
    "\n",
    "def display_sample(dataset, labels, title_label, session=None):    \n",
    "    gs = gridspec.GridSpec(4, 4)\n",
    "    gs.update(wspace=0.3, hspace=1)\n",
    "    fig = plt.figure()    \n",
    "    fig.suptitle(title_label, color='white')\n",
    "    fig.patch.set_facecolor('black')\n",
    "    for d in range(0, 16):\n",
    "        a=fig.add_subplot(gs[d])\n",
    "        letter_idx = int(len(dataset)*random.random())\n",
    "        #print(letter_idx)\n",
    "        plt.imshow(dataset[letter_idx].reshape((28,28)), cmap = cm.Greys_r)\n",
    "        l_title = chr(tf.argmax(labels[letter_idx],0).eval() + ord('A'))\n",
    "        if session is not None:\n",
    "            letter_class = predict_letter(dataset[letter_idx], session)\n",
    "            #print letter_class\n",
    "            l_title = l_title + ' / ~' + chr(letter_class + ord('A'))\n",
    "        a.set_title(l_title, color='white')\n",
    "        a.axis('off')    \n",
    "    plt.show()\n",
    "    \n",
    "def display_incorrect_sample(dataset, labels, title_label, num, session=None):    \n",
    "    gs = gridspec.GridSpec(4, int(num / 4) + (0 if num % 4 == 0 else 1))\n",
    "    gs.update(wspace=0.3, hspace=1)\n",
    "    fig = plt.figure()\n",
    "    fig.suptitle(title_label, color='white')\n",
    "    fig.patch.set_facecolor('black')\n",
    "    incorrect = find_incorrect(dataset, labels, session)[0]\n",
    "    no_incorrect = len(incorrect)\n",
    "    print('Incorrect no: %i' % no_incorrect)\n",
    "    #get permutation of incorrects\n",
    "    incorrect = incorrect[np.random.permutation(no_incorrect)]\n",
    "    for d in range(0, num):\n",
    "        a=fig.add_subplot(gs[d])             \n",
    "        letter_idx = incorrect[d]\n",
    "        #print(letter_idx)\n",
    "        plt.imshow(dataset[letter_idx].reshape((28,28)), cmap = cm.Greys_r)\n",
    "        l_title = chr(tf.argmax(labels[letter_idx],0).eval() + ord('A'))\n",
    "        if session is not None:\n",
    "            letter_class = predict_letter(dataset[letter_idx], session)\n",
    "            #print letter_class\n",
    "            l_title = l_title + ' / ~' + chr(letter_class + ord('A'))\n",
    "        a.set_title(l_title, color='white')\n",
    "        a.axis('off')    \n",
    "    plt.show()\n",
    "    \n",
    "def restore_and_display_test(graph, title, display_all=False):\n",
    "    with tf.Session(graph=graph) as sess:\n",
    "        sess.run(tf.initialize_all_variables())\n",
    "        #load model\n",
    "        if display_all:\n",
    "            filenames = saver.last_checkpoints\n",
    "        else:\n",
    "            ckpt = tf.train.get_checkpoint_state('./')\n",
    "            #print ckpt\n",
    "            if ckpt and ckpt.model_checkpoint_path:                \n",
    "                filenames = [ckpt.model_checkpoint_path]\n",
    "        for fn in filenames:\n",
    "            saver.restore(sess, fn)\n",
    "            print(\"test accuracy %g %s\" %\n",
    "                (accuracy_l.eval(feed_dict={ tf_train_dataset: test_dataset, tf_train_labels: test_labels,\n",
    "                                        tf_keep_prob: 1.0}), fn))\n",
    "            #display_sample(test_dataset, test_labels, title +' %s' % fn, num_samples, sess)\n",
    "        \n",
    "def restore_and_display_random_incorrect(num_samples, graph, title, display_all=False):\n",
    "    with tf.Session(graph=graph) as sess:\n",
    "        sess.run(tf.initialize_all_variables())\n",
    "        #load model\n",
    "        if display_all:\n",
    "            filenames = tf.train.last_checkpoints\n",
    "        else:\n",
    "            ckpt = tf.train.get_checkpoint_state('./')\n",
    "            #print ckpt\n",
    "            if ckpt and ckpt.model_checkpoint_path:                \n",
    "                filenames = [ckpt.model_checkpoint_path]\n",
    "        for fn in filenames:\n",
    "            saver.restore(sess, fn)\n",
    "            print(\"test accuracy %g\" % \n",
    "                accuracy_l.eval(feed_dict={ tf_train_dataset: test_dataset, tf_train_labels: test_labels,\n",
    "                                        tf_keep_prob: 1.0}))\n",
    "            display_incorrect_sample(test_dataset, test_labels, title +' %s' % fn, num_samples, sess)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "KedKkn4EutIK"
   },
   "source": [
    "---\n",
    "Problem 1\n",
    "---------\n",
    "\n",
    "The convolutional model above uses convolutions with stride 2 to reduce the dimensionality. Replace the strides by a max pooling operation (`nn.max_pool()`) of stride 2 and kernel size 2.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "patch_size = 5\n",
    "depth = 16\n",
    "hidden_nodes = 64\n",
    "\n",
    "graph = tf.Graph()\n",
    "with graph.as_default():\n",
    "    # Input data. For the training data, we use a placeholder that will be fed\n",
    "    # at run time with a training minibatch.\n",
    "    tf_batch_size = tf.placeholder(tf.int32)\n",
    "    tf_train_dataset = tf.placeholder(tf.float32, shape=(None, image_size, image_size, num_channels))\n",
    "    tf_train_labels = tf.placeholder(tf.float32, shape=(None, num_labels))    \n",
    "    tf_keep_prob = tf.placeholder(tf.float32)\n",
    "\n",
    "    # Variables.\n",
    "    # input layer variables\n",
    "    weights_conv1 = weight_variable([patch_size, patch_size, num_channels, depth], patch_size * patch_size)\n",
    "    biases_conv1 = bias_variable([depth])\n",
    "    weights_conv2 = weight_variable([patch_size, patch_size, depth, depth], patch_size * patch_size)\n",
    "    biases_conv2 = bias_variable([depth])\n",
    "    weights_h1 = weight_variable([image_size / 4 * image_size / 4 * depth, hidden_nodes],\n",
    "                                 image_size / 4 * image_size / 4 * depth)\n",
    "    biases_h1 = bias_variable([hidden_nodes])        \n",
    "    # output layer variables\n",
    "    weights_o = weight_variable([hidden_nodes, num_labels], hidden_nodes)\n",
    "    biases_o = bias_variable([num_labels])        \n",
    "    # Model.\n",
    "    def model(data):\n",
    "        conv = tf.nn.conv2d(data, weights_conv1, strides=[1, 1, 1, 1], padding='SAME')        \n",
    "        #conv = tf.nn.conv2d(data, weights_conv1, strides=[1, 2, 2, 1], padding='SAME')        \n",
    "        pool = tf.nn.max_pool(conv, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')\n",
    "        hidden = tf.nn.relu(pool + biases_conv1)\n",
    "        \n",
    "        \n",
    "        conv = tf.nn.conv2d(hidden, weights_conv2, strides=[1, 1, 1, 1], padding='SAME')        \n",
    "        #conv = tf.nn.conv2d(hidden, weights_conv2, strides=[1, 2, 2, 1], padding='SAME')        \n",
    "        pool = tf.nn.max_pool(conv, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')\n",
    "        hidden = tf.nn.relu(pool + biases_conv2)\n",
    "        \n",
    "        #reshape multidimensional output to flat to connect to dense hidden layer\n",
    "        #shape = pool.get_shape().as_list()\n",
    "        #hidden_flat = tf.reshape(pool, [-1, shape[1] * shape[2] * shape[3]])\n",
    "        shape = hidden.get_shape().as_list()\n",
    "        hidden_flat = tf.reshape(hidden, [-1, shape[1] * shape[2] * shape[3]])\n",
    "        hidden = tf.nn.relu(tf.matmul(hidden_flat, weights_h1) + biases_h1)\n",
    "        return tf.matmul(hidden, weights_o) + biases_o\n",
    "\n",
    "    #output operation\n",
    "    logits_o = model(tf_train_dataset)    \n",
    "    y_conv = tf.nn.softmax(logits_o) #after softmax -> output probabilities / predictions\n",
    "    #define loss\n",
    "    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits_o, tf_train_labels))\n",
    "                        #+ (2.0/(3*hidden_nodes))*(tf.nn.l2_loss(weights_i)\n",
    "                        #+ tf.nn.l2_loss(weights_h2)\n",
    "                        #+ tf.nn.l2_loss(weights_h3)))\n",
    "    #decay learning rate\n",
    "    global_step = tf.Variable(0)\n",
    "    learning_rate = tf.train.exponential_decay(\n",
    "        0.1, global_step * tf_batch_size, train_dataset.shape[0] / 1, 0.95, staircase=True)\n",
    "    #Optimizer\n",
    "    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)\n",
    "    #learning_rate = tf.constant(0.01)\n",
    "    #optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss, global_step=global_step)\n",
    "\n",
    "    #define operations to measure accuracy\n",
    "    is_correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(tf_train_labels,1))\n",
    "    accuracy_l = tf.reduce_mean(tf.cast(is_correct_prediction, tf.float32))\n",
    "    #train_prediction = tf.nn.softmax(logits_o)\n",
    "    #valid_prediction = tf.nn.softmax(model(tf_valid_dataset))\n",
    "    #test_prediction = tf.nn.softmax(model(tf_test_dataset))\n",
    "    #saving mode\n",
    "    saver = tf.train.Saver(max_to_keep=20)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized\n",
      "Minibatch loss at step 0: 3.795160 with learning rate 0.100000\n",
      "step 0, training accuracy 0.226562\n",
      "Validation accuracy: 0.152692\n",
      "Minibatch loss at step 500: 0.544031 with learning rate 0.100000\n",
      "step 500, training accuracy 0.882812\n",
      "Validation accuracy: 0.860073\n",
      "Minibatch loss at step 1000: 0.379463 with learning rate 0.100000\n",
      "step 1000, training accuracy 0.914062\n",
      "Validation accuracy: 0.878925\n",
      "Minibatch loss at step 1500: 0.486052 with learning rate 0.100000\n",
      "step 1500, training accuracy 0.890625\n",
      "Validation accuracy: 0.885495\n",
      "Minibatch loss at step 2000: 0.412556 with learning rate 0.100000\n",
      "step 2000, training accuracy 0.90625\n",
      "Validation accuracy: 0.89217\n",
      "Minibatch loss at step 2500: 0.468669 with learning rate 0.095000\n",
      "step 2500, training accuracy 0.859375\n",
      "Validation accuracy: 0.896069\n",
      "Minibatch loss at step 3000: 0.316876 with learning rate 0.095000\n",
      "step 3000, training accuracy 0.921875\n",
      "Validation accuracy: 0.897084\n",
      "Minibatch loss at step 3500: 0.430827 with learning rate 0.095000\n",
      "step 3500, training accuracy 0.898438\n",
      "Validation accuracy: 0.896657\n",
      "Minibatch loss at step 4000: 0.350021 with learning rate 0.095000\n",
      "step 4000, training accuracy 0.90625\n",
      "Validation accuracy: 0.901997\n",
      "Minibatch loss at step 4500: 0.300836 with learning rate 0.095000\n",
      "step 4500, training accuracy 0.921875\n",
      "Validation accuracy: 0.897565\n",
      "Minibatch loss at step 5000: 0.356908 with learning rate 0.090250\n",
      "step 5000, training accuracy 0.90625\n",
      "Validation accuracy: 0.902104\n",
      "test accuracy 0.953642\n"
     ]
    }
   ],
   "source": [
    "train_model(5001, 500, 128, graph, is_saving=True, keep_prob = 1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test accuracy 0.953642\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAESCAYAAAB5KIfmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nFAgEgjAQoikQCARhIERTIBAIwuD/AIZlF6qoWji6AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9af700cad0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test accuracy 0.953642\n",
      "Incorrect no: 868\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAESCAYAAAB5KIfmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsnXlYVEe6/7+nF7obuhuapdn3VRRQRBRjxA0V90SRqDGJ\nJmMmyZNJvONz586T3Cx3st3nTjKZGMckkxmTGNGYuMQF1AgYQUAFQWRVWRpBaLZe6Kbpha7fH/7O\nCbiCAo1yPs9TD3SfU3Wq3q7znreq3noPBYCAhYWFhWVAcGxdARYWFpaHCVZpsrCwsAwCVmmysLCw\nDAJWabKwsLAMAlZpsrCwsAwCVmmysLCwDAJWabIMCq1WCwCIjo7GmTNnUFpaiuLiYqSkpIzI9f/y\nl79AoVBAo9H0+57P52P37t24fPky8vLy4OvrO+B6/v3vf2faxcIyEAib2DTQpNFoCAASEhJCgoKC\nCADi4eFBmpqaiEQiuWteDofzwNefMmUKkcvlTD3o9Pvf/55s27aNACCrV68mu3fvHlA9Y2Njybff\nfntLeWxi012SzSvApoco3Um5FBcXM8qpb8rKyiKffPIJOXfuHHn99deJi4sL+fHHH0lBQQEpKCgg\nCQkJBABxcXEhx48fJ6WlpeSrr74idXV1RCaTDbgeGRkZJD4+ngA3lHNra+s960lRFMnMzLytEmYT\nm+6SbF4BNj1E6XbKZcqUKaSsrOy252dlZZGtW7cyn7///ntGUfr4+JDy8nICgHz22WfkP//zPwkA\nMn/+fGKxWAalNEtLS4mnpyfz+fLly7fkv7mer776Knn11VcJAKLVam0uWzY9HIkHFpYHwMPDA999\n9x3Wr19/x3N++OEH5v958+Zh3LhxoCgKACAWi2Fvb48ZM2ZgxYoVAIATJ05ApVI9UL3o8u9UTw8P\nD6SkpCAxMfGBrsMy9mCVJst9IxaLceTIEfz5z39GYWHhHc/T6/XM/xRFYerUqbBYLP3OIYT0+3yz\n0rsXjY2N8PX1RXNzMzgcDqRSKaN4b1fPSZMmITg4GFevXgVFUbC3t0d1dTXCw8MHdV2WsQe7es4y\nKGhlxuPxcPDgQXz77bc4ePDggPOfOHECr732GvM5OjoaAHDmzBmkpqYCAJKSkuDk5DSgetAcPnwY\nzz77LAAgJSUFWVlZd61nRkYGvL29ERwcjKCgIHR3d7MKk2XA2HyOgE0PT6LnEteuXUt6enpIUVER\nuXDhAikqKiJRUVG3nJ+ZmUkmTZrEfHZ2dia7d+8mJSUl5NKlS8yKt6urKzlx4gS5ePEi+eKLL0hj\nYyPh8Xi3lPfRRx+RhoYGYjabiUKhIP/93/9NABA7Ozvyww8/kMuXL5P8/Hzi7+8/qHqyC0FsGmii\n/v8/LCw2hc/no7e3F1arFVOnTsU//vEPTJ482dbVYmG5hREZnmdlZWHDhg13PL59+3Y8//zz913+\nW2+9BaPRCI1GA41GA61Wi46Ojvsu72Gkrq4Oer2eab9Go4G7u/sdz//Tn/6Ev/zlL/d9vZkzZ6Kh\noeG+89+Mn58fzp8/j+LiYvz973/H7373uyErm4VlKBkVc5rJyclIT09/oDL27NkDR0dHODo6QiqV\nwsXFZYhq93BACMHixYuZ9js6OkKpVN7x/MWLFz+wzG9evHkQampqMHnyZEyaNAnTpk3DhQsXhqzs\nB2XNmjU4d+4ctFotGhsbceTIEUyfPv2ueSorKxEcHHzf18zOzkZ3dzdjCGg0mkHNHT9M2EK+wA1P\njszMTGg0GrS2tqKoqAhbtmwBn8+/az6bK80JEyZApVKhubnZ1lV56BnoirOjoyNCQ0ORn58/zDV6\n+Nm8eTM++eQTvPfee5DL5fDz88O2bduwdOnSO+YJDAwEh8NBTU3NfV+XEIKXX36ZMQQcHR0Zl6xH\nCVvJd9WqVfjxxx/x/fffw8/PD3K5HKmpqfDx8WG24N4Jm7scLVq0CEePHrV1NcYUCxYsQGZmpq2r\nMeqRSCR499138eyzz+LQoUPM9xkZGcjIyLhjvqGw4oHBu109bNhSvh9//DHeeecd7Nixg/nu6tWr\neP311++Z1+aW5t0EIJVKsX37digUCpSXl+ONN95AQEAAfH198dVXX8HHx4c5NzU1FR0dHUw6efLk\nSDVh1HDw4EGm/fv27bvjeXeTOZ/PxwcffIArV66gpqYGH3zwAcaNGwe5XI6//OUveOyxx4ar+qOO\nhIQECASCQQ+LWUNgYNhKvmFhYfD29sb+/fvvK79NlaZUKkV4eDjy8vJue3zhwoUoKipCUFAQVqxY\nARcXF+Tm5iI9PR3FxcVobGxkzv3hhx/g4uLCpHnz5o1UM0YNy5cvZ9q/cuXKO56XlJSEY8eO3fbY\n1KlTodPpMGHCBMycORNmsxlHjhxBbm4uTCbTHX+rRxEXFxe0t7cPau5WKBQiLi4Op06duu3x8PBw\nHD58GM3NzcjJycGGDRvg6uqKSZMmYefOnf3O3bp1Kzo6OtDZ2YmOjg688847D9Ca0Yet5Ovq6goA\naGlpYfKlpaWhs7MTOp0Oa9euvWc9ht2vKSsri2zYsOGW71NSUkhaWtoDl//WW2+Rb7/91ub+W7ZM\ntbW1ZPbs2fc8b8qUKSQvL++Brzdz5kyiUChs3u7hTPPnzydGo5FQFDXgPIsXLyYHDx684/F3332X\nzJw5k1AURWbMmEH27t1LlEolycnJIYmJicx5d7pnHqVkK/mGh4cTi8VC/Pz8bsl/+vRpsn79+rvW\nwaZzmuwwZuRhZT5w8vPzYTQasWLFChw4cGBAeRYtWnTX+ba3336b+T83Nxe5ubkPXM+HFVvJt7q6\nGk1NTXjyySfx6aefDrreIzY8v50JvmDBgjsOEwdLampqPz9NjUYzptyOBjrEGapFisFc82Glq6sL\nb7/9NrZt24Zly5ZBKBSCy+ViwYIF+PDDD2+bJzk5mX0oDRBbynfLli14++23sXHjRjg6OgIAQkJC\n7urb3JdhN8MLCwvJ0qVL+30XFxdH8vPzbT5EGEvJzc2NXLt2bUjKWrJkCSkqKrJ5m0YiPfXUU+Tc\nuXNEq9WSpqYmcujQITJ16tRbzouMjCQXL14ckmtmZWURvV5PNBoN0Wg0RKvVknPnztlcFo+KfAGQ\npKQkkp2dTTQaDWltbSWFhYVk8+bNRCgU3ivv8AokMjKS6HQ64uPj0+/7uLg4Mn/+fJv/YGMphYSE\nkNWrVz9wOVwul+zYsYN8+eWXNm/TaEpbtmwhH374oc3r8aimUSTf4Sv8ww8/JA0NDeTll1+2dSPZ\nNERJIpEQtVpNfvnlF+Ll5WXz+oymtHLlShIWFmbzejyqabTIlw3YwcLCwjIIbO7czsLCwvIwMWIu\nR/SWsL5/e3t7sXTpUjzzzDPw9fXF6dOn8dVXX/XbU0qfLxQKER0djejoaISGhsLLywvAjajgYrEY\n4eHhoCgKX3/9NQ4dOtTP8f1Rh6IoEELA4XAQExODJ598EvPnz4eXlxekUimzKsnh3HhGEkJACIHF\nYoHRaER3dze0Wi3a2tpQW1uL3Nxc/Prrr1AoFOjp6WGuAQB2dnbw8/ODv78/BAIBrl+/juLiYpu1\n3ZbQMuFyuZg+fTqeeeYZxMTEwNHREUajEU1NTbh69SrUajU0Gg2MRiN4PB7s7Ozg4OAAZ2dnODs7\nQyaTQSKRwGKxoLW1Ffn5+Thx4gQqKipgtVpt3ErbQFEU069dXFywYcMGPPbYYyCEoKqqCiUlJaiv\nr0dXVxd6e3tBURREIhHc3d0RHh6O6OhoyGQyFBcX4+jRo7hw4QLzez2o14dNhud9Kz937lw88cQT\nkEqlqKqqgkajwddffw2TycQ0jlaKc+fOxbFjx7BmzRr4+PigpaUF5eXluHr1Kvz8/ODh4QFPT0/k\n5OTg5MmT6O7uHumm2QyxWIzVq1fjiSeeQHR0NDw9PcHj/fZMpDsgLdPbdSCLxQKdTgelUonGxkZc\nvXoV+fn5yM3NRV1dHQCAw+HA3t4eYrEY48aNQ3R0NJRKJfbs2TOCrbUtfaPXBwcH45VXXsGkSZMg\nFouRn5+P8+fPo7GxERqNBmq1GiaTCUajEVarFRwOBxwOB3w+HyKRCCKRCGKxGL6+vpgxYwYSEhJg\nZ2eHK1eu4MiRI/juu++YB9dYoe/7o2bNmoU1a9ZAIpEgLy8P+fn5aGlpQVtbG7RaLcxmM5OPx+NB\nJBJBJpPB3d0dkZGRmDNnDiQSCbKzs/Hdd99Bo9Ew98L9MmKWJt0QqVQKq9WKjo4OtLS0oKKiAs7O\nzvDy8kJ3dzdcXV0hkUigUqnA5/Ph4eGB8ePHIyIiAi0tLaitrUVDQwNaWlpw5coVdHZ2gsfjobm5\nGU5OTvDz80N8fDwaGhpQUlLywAJ6GBAIBFi/fj3Wr1+PqKgo8Hg86HQ6WCwWxrKxs7MDl8u9YxAI\niqLA5/Ph5OQEJycnhIWFYfLkyYiLi0NiYiJKS0tx7tw5lJeXQ6fTQafTgcPhwNfXF+vWrRszSpOW\nn7OzMxISErB69WokJCTgl19+QXFxMc6fP4+amhrodDpQFAUOhwOr1cpYjDweDz4+PggPD0dQUBDc\n3NwgFoshk8mYz87OzvD19QVFUUyM0bECLV9PT08kJyfj6aefRm9vLw4ePIhjx46hvr4eVqu1nwFA\nY7FY0NXVBb1ej8bGRtTW1kKtViMlJQXr16+Hq6sr/vnPf0KpVMJisdy3XhgRpenp6YnQ0FBGIUql\nUly7dg0hISEwm81wdHSETqdDS0sL7O3tQQgBl8tFZGQkfHx84OjoCJVKhYKCAri5ucFgMKC2thaN\njY0ICQnB/PnzYTAYmPfKODg4wMvLC+Xl5eBwODAajSPRTJuxcOFCPPvss3B3d8fZs2dRWVmJjo4O\nmM1mxqKRSCRwc3ODn58f/Pz84Ozs3M8SBfpbnRwOBzKZDHFxcYiKisKcOXNw9uxZFBcXo66uDtev\nXwdFUZDL5YiLixvpJtsE+oZ2dXXFvHnz8NRTTyEwMBC7d+/Grl27oFAoYDabQQhhhpd0PhcXF4SH\nh8PPzw+BgYHw9/eHi4sL7OzsYLVaYTKZ0NTUBIVCwfT/hoaGMTU8p+Xl4+ODRYsWYcOGDQgODsab\nb76JgwcPorW1dUBGEC1/lUqFY8eOQSAQYPPmzfjd737HTOFdv34dvb2996U4h11p8ng8TJw4ERKJ\nBHq9HjweDx4eHuBwOMycm1wuR11dHTo6OhAUFASTyYTx48cjISEBarUa58+fR3t7O3p7e+Hj44PO\nzk5mo7+Liwv8/PygVqvB5XLR1dUFi8UCFxcXeHl5QavVPvJK87XXXoODgwNOnDiBAwcO4Ny5c+js\n7GSO8/l8Zgg4YcIETJo0CYGBgfD29oa7uztcXFxgb28PLpfbrxPR/9vZ2cHf3x8BAQFYtmwZ6urq\ncPnyZZjNZgQEBMBgMIx4m22FRCLB7Nmz8fTTT8PT0xPffPMNPv/8c5hMJmbemFZ0IpEIHh4e8Pf3\nR2BgIEJDQyGRSBgFWVhYiJaWFrS3t0Oj0cBkMsFisaC3txccDgdmsxnt7e02bvHI4uzsjKSkJGzY\nsAETJkxAYWEhjh07hra2NgAY0EOEtkK5XC5MJhNKSkqQnZ2NP/7xj3jttdfQ0tKCAwcOoKWl5b5G\nosOuNN3d3eHj44OysjKo1WpERERAq9Wivb0d58+fh4eHBwICAuDs7Iz4+HgQQuDj44PVq1dDpVLh\nzJkzqKqqAp/Ph0wmQ3V1NaqqqiCTySAWi1FRUQGhUAitVovY2FgEBwfD09MTHA4Hra2td3217KPC\n5MmT8eWXX2LHjh2oqqpivqef3GazGSqVCiqVCpcuXcKePXvg4OCAyZMnY8aMGYwSdXZ2ZuYr7ezs\nwOFwmA5IP71FIhEiIyMxbtw4GI1G1NXVYe/evbZq+ohByzI+Ph4bNmyAj48P/vWvf+HTTz/tN0cp\nFAohFAohFosREBCA2bNnY8GCBWhvb8fx48exa9cuXLlyZUw9aAYCbZknJCRg1apViIuLg1qtxsWL\nF6HT6e6rTHoY39LSgqqqKphMJkgkEmzevBnXr1/HiRMnmPniwSjOYVeaU6dOhUqlQmhoKPh8PrP6\numnTJmRlZcHOzg4GgwEeHh4IDAxEYWEh5s+fj5aWFpw8eRKXL18Gn88Hl8uFTqeD2WwGRVEwm83o\n6upCd3c3ZDIZPvroIzQ3N8PZ2RkURaGpqQkAxsRikFqtxoEDB3DlypV+39/cETgcDvNk7erqwqlT\np3Dq1Cnw+Xx4eXkhLi4OcXFxmD9/PgIDAyEQCPrlA37riGazGdXV1di9ezc+++yzkWmoDSGEQCqV\nYtOmTYiJicE///lPbN++HRRFQSgUwtfXFxMnTkRkZCQiIyMREREBX19fcDgc5Ofn49lnn0Vrayus\nVisz19nXyrnTTfuoz8fT0PJ94oknMGvWLOaBbTAYmAc2fd5Aoa1+k8kEvV7PWKkhISF44oknoFQq\ncf78ecYoGOhUyLArTQcHBzg4OEAoFKK4uBgKhQKzZ8+GTCZDeXk5ysvLmWE73cjm5mZ0dXVBKBRC\nIBCAw+EgLCwM4eHhOH78OGQyGfR6PSIiIpCQkACtVouzZ8/C19cXQqEQwA0Ld+LEidBqtY/8ax3o\nuR4Oh4Pe3t47nkffsDS0C5LFYkFjYyOUSiVOnjwJtVoNJycnKJVKUBQFb29vODg4gMfjQaVSoamp\nCeXl5aiurmaGTWOBZ555BtHR0UhPT8e+fftgNBrh4eGBV199Fc8++yykUiljMfF4PFgsFuTl5THB\nZPoqyrGiDAdDamoqJk+ezMzzPqic6HshIiICc+fOhb29PXNs6dKl0Ol0MBgMzILxQBl2pcnhcGBn\nZ8fM17i6uiI4OBhVVVX45Zdf+s3Z0Dc1bUnyeDzmu66uLpw/fx7d3d3g8Xjw8/NDeHg45HI5JBIJ\nmpubIRKJ0NTUhEuXLkGpVMLZ2RnTpk175JVmcXEx5syZA41Gg/Ly8rt2gL7zlBaLhZEvIQT29vZY\ntmwZkpKS8NFHH6G4uJhZVadveHryvLu7G93d3bBYLCPVTJvS9x09+fn5qK6uhp2dHYKDg/H000/D\nw8MDR44cweHDh2FnZ4fly5cjKCgIJ06cYObbaUXAcisuLi6YO3cu/Pz8Hsjjhe77/v7+2LRpE8aP\nHw8vLy/4+/v3m26SSCRISUnBtGnT0NDQgM7OzgG/EXfYlaZAIEBtbS18fX2xYMECUBSF1tZWZGZm\noqOjAz09PYz5LZFI4Ovri+rqavT29qK7uxt8Pp95u6RYLEZUVBRMJhM8PDzQ2dmJgwcPYurUqZg1\naxacnJxQUVGB+vp61NfXIz4+HgsXLsTf/va34W6mTdm6dSuWLFmC5ORkeHp6oqysDJ2dnTCZTAB+\ne3CJRCLG6tfr9f2iZkulUsyYMQObN28GRVFMmD1CCHg8Hnx9fbFkyRJMmDABjo6OsFqtUCqVyMvL\nw/79+5lrParMmTMHgYGBOH36NIqLi2E0GpmFR3rOLTQ0FKmpqRAKhQgMDITJZGLebEgvsrGW5u2Z\nPHkywsLCIJFIhqQ8nU6HkpISNDY23vVhRSvZu43QbmbYlea1a9fA4XCg0Wjg5OQEiqJQWFiImpoa\nWCwWCAQCiEQiWCwWWCwWGAwGODo6wmw2M87A9vb2kEgk0Gq18PHxgUQigZeXF9RqNWOZBgYGore3\nF/b29vDx8YFMJkNoaOiQvpt7tFJWVgY+n4+AgADIZDLExMRAq9Wip6cHPB6Pma8xmUwwGAwwGAzo\n7u5m5nD4fD5iYmKwadMmTJgwAW1tbfD29kZ1dTV6enoQFBSEpUuXgsfjYc6cOfD29mYUa0REBCiK\nwu7du20sheFl5cqVEIvFOHv2LOPob7Va0dDQgI8++giJiYmQy+WgKAomkwlarRYSiQRisRgA7jl3\nOdaZOXMmXF1dGYv8fqHlq1arkZ2dzXgh3KwU6QcYl8tlRlIDhQvgnfuu4QAwGAzw9fWFq6sr49pC\ne/F3dHRAJBLB2dkZHA4HWq0WJpMJMpmMaRC9Rcre3h69vb24fv06E2SYVromkwkikQhWqxVNTU3Q\n6XQQCoXQ6XQ4fvz4I684KYpCS0sLlEolDAYDM4ymHzr0lkmdTgeVSoXOzk5m9ZYQgsDAQKxatQpr\n165ldlX09vaivr4eZrMZ8fHxmDZtGn755RckJyczv5dIJIJUKgWAR/ad3DT/93//B0IIdu3ahfLy\ncubm7OnpQWVlJWpra3H58mWcP38eZ8+ehVAoxPjx49HZ2YnS0lKMHz8e8fHxiImJgVQqZR5cLDeg\nX5ooEAgY2RoMBhQXFyMvL49xGxzoQ8dqtaK7uxt6vR4GgwFGo/G2yWAwQK/XD2qFftgtzaamJri5\nucHV1ZXZ+cDhcKDX66HX6xlnYC6XC1dXV1AUhe7ubvT09MBqtUIoFEIikUAkEiE4OBjV1dUoLy+H\nRqOBXC6Hh4cHzGYzmpqaEBUVBUII2traUF9fj7q6OigUiuFuos3p68zb2dnJzEM6OjoynZBeQey7\nGkkPFWNiYpCYmAihUAir1Qoul4snn3wSarUa1dXViIiIgE6nw5UrV6BWq2GxWMDn82G1WqHX63Ht\n2jVbi2DYcXd3Z9zm+g6zgRsuXaWlpbh06RIjVzc3N8yaNQtTp07FCy+8gIiICAQGBsJiseDSpUvI\nyMhAdnY2Wltbbdyy0UFoaCiziDtUu/gG+wrkgV5zRHYElZSUoKKiAqGhoQgODoZGo8H58+eZle/G\nxka4uLhg3LhxuH79OkpLSxkXAW9vb8TGxsLT0xNyuRxJSUnYu3cvqqurIZVKQQhBYWEhamtrUVpa\nipUrV4KiKNTX10OhUPRzNn6UoW9kHo/H+LTGxsYiIiKCWfVWKBSoqamBUqns92SlfWWB3zqavb09\nXnjhBRiNRsYDob29HVlZWSCEwNXVFd3d3Th//jy++eYbG7R4ZBGJRLh+/fodrUN6oYz2YCgpKUFG\nRgbWrl2Ll19+GZ2dnaivr0dDQwMCAgLw3HPPgcfjYdeuXWOmj94NqVQKLpc7pGUO11TIiChNLpcL\ns9kMs9kMBwcHiMVilJeXIycnB4QQBAcHY/HixZg6dSrOnDkDkUiEkpISdHV14dq1a1CpVAgJCcHy\n5ctx8uRJxoWgo6MDWVlZzF5re3t7SKVSZnGJHpqOFejFNJlMBmdnZ/j5+eGll16Cr68vuFwu417x\n+eef4+DBg4zPq8Vi6Rf4gIZ21JZKpUhISEBiYiLef/997Nq1C56enujo6EBVVdV9Ox8/TFAUhc7O\nThiNxtv6DNJKj547Kysrw+eff47Ozk7MmjULO3bswC+//AK9Xo81a9bgxRdfxPLly7F79+4xrzCB\nGw/pm31XRysjojRpIXh4eCAkJASdnZ14/PHHoVar4ejoiClTpsDT0xPNzc2YNm0ali9fjoaGBlRU\nVMBoNEIoFKKtrQ1ffvklmpubwefzER0djeTkZDz33HPw8fFBQUEBnnzySYhEIlRWVjKh4Ub7DzCU\nBAUFQSgUoqWlhZHfuHHjsHLlSri7u0MoFCI+Ph4ffPABNBoNcnJyoNPpUF9fj8rKSvj7+99SJi0/\nLy8vfPnll3jxxReZXVqEEGbOeSzImQ6CMlAaGxuRlpaGxsZG8Hg8pKamYtq0aZg+fTpcXV1RUVEx\njLVlGS6GXWlSFAWr1cpscayqqkJubi7c3NzwxhtvQKVSISMjAyUlJfDz88O6devw66+/4tKlS9Bq\ntczcp9FohEajQW9vL3p6elBUVISrV68iODgYjz32GDZu3AiKopCVlYVLly6Nuae3j48PBAIB1Go1\nVCoVCCGws7NDVFQU43QN3LD65XI5nnnmGVRUVECn0+HixYvIzs7GrFmzmHklGjofh8OBXC7HBx98\ngPfffx/Hjh0bkjBbDwsGgwFSqRR8Pv+e7aVl5ubmhiVLluA//uM/QAhhYgAYDAYcOHAAX3/9dT8/\n2bFMd3c3HBwcBj0PaQuGXWkSQiCXyxEdHY2enh6UlpYiKCgIiYmJsFqtaGtrg9lsRlhYGAICAnD8\n+HGcP38eKpUKVqv1jkNH2nVGq9Wio6ODGS42NDRAq9WOuU6o0+mg1+uZBTQXFxe88MILCAsLu0UR\n8vl8REZGQigUgsPhoLOzE7m5uThy5AhWrVrVb9safUPTn8PDw/GHP/wBdnZ2OHTo0JhRnCqVCm5u\nbv12ldyJvqu/KpUK3t7esFqt2Lt3LxM898qVK6itre13/s3QbjBjwQCgdwAO5bzmQ70QRPtWtrS0\nQKfTIT4+Hk5OTtizZw88PDzQ09MDDocDiUSCpqYmmEwm9PT03NXhlG6gXq9HVVUVFAoFjEbjoJxU\nHyW6uroA3JCLk5MTEhIS8Nxzz8HFxYW5+e6k3CwWC6qqqvDNN9/AxcUF06dPh52dXT+F2devLTY2\nFs899xxMJhP27t07Jm7qsrIyuLu7w8HBYcB5DAYDWlpaYDQaYWdnh/z8fKSnp6OlpaVfkO2bGaoI\n4w8TV65cgUQigZ2d3ZC1+6FeCKJ38/B4PEgkEkgkEmRmZuLMmTNYvHgxEzg0KioKSUlJ8Pf3R2lp\nKSoqKqBSqe5ZPr2t72Ew7YcLem6Ry+UiJCQE69atQ1hYGHP8di4yfd2P1Go18vLymOhGsbGxEIvF\nt7ymBLhhqcbHx6O5uRkXLlzA5cuXR7axNuDEiRN44YUX4OnpCZFIdFcfS9qvODIyEgsWLACXywWP\nx8P06dNRW1uLrq4uZvR0pxvb2dkZgYGBsLe3R2lpKdRq9bC0a7SQn5+P0NBQxu/3QeHxeIx7o8lk\nYoypmx9ItHM7l8tFc3PzwMoekhreA3obZHBwMOzt7eHs7Izdu3fDZDIxW5x0Oh00Gg2zq8Xd3R1a\nrRZarXbA1uNYejLfDK0U3dzcMGPGDCQnJ/c7Tsumt7cXra2t2LdvH3Mj0tv6NBoNjh49Cj6fjxdf\nfBFxcXGMW9fNw3WRSITx48dj1qxZY0JpHjt2DGvXrsXEiRNx4cIFJqLUzX2OoijY2dkhOjoaGzZs\nwKpVq9D5RbFoAAAgAElEQVTe3g4nJyesWbMGKpWK8Qi5OR9w4yb29/fHzJkzMWvWLEgkEuzcuRMH\nDhwYmYbaiNOnT2PRokVMrN0H3Xvu6OiIWbNmwcXF5ZbwhsBvv1vf6F1ff/31gK4xInvP5XI5DAYD\ngoKCMHXqVOj1esTFxaGoqIiJWHTt2jXk5ubCbDZDJBLB09MT9vb24PF4Y3bIPRjoHz8mJgbJycmQ\nSCS37SQqlQrZ2dnIyMi4JTgzvRr+448/Mu4fCQkJEAqFt3QyiqLg7u6OmJiYkWqiTamoqEB5eTni\n4+OZaF30xgwa+oHi4+ODlJQUrF27FkqlEnv37sXixYsRGhraz2Lva/1zOBzweDwEBQVhw4YNSE1N\nha+vL7RaLXg83iOvNAsLC3H58mUEBAQMibUplUoRGxuLqKgoeHt7w8/Pj3mzA3BDSWo0GjQ2NkKh\nUKCzs3PASnPYX+Hr5eUFZ2dnXLhwAbW1tZDJZHB1dcU777wDFxcXmEwmPPbYY3j++ecRGxuL2tpa\nLF68GAaDAZ2dnYwvIcvdoZ+kvr6+iIyMvOU4RVEwGo24cOEC3nvvPZhMptvKld4R9MMPP2Dnzp3M\nlsHbPfmFQiEcHR2HpT2jke+//x4ikQgzZsyAv78/4wtMQ8tz1qxZmDdvHvR6PU6cOIH3338fNTU1\nMJvNqKmpQVtbG+MITycul4vx48fjf//3f/HSSy8xi0eDifP4MNPR0YHMzEzmdR/3C91X6+rq8Oc/\n/xlLly7Fpk2bcPDgwX474bq7u7Fv3z48//zzWL58OTZu3Djgawy7pdnW1obOzk7MnTsXXC4XRUVF\naGlpAZ/PR1tbG9LS0iCXyxEcHIzw8HAsWrQI+/btw/Hjx9HW1jYmOsxQQt+At6OwsBBffvklFAoF\n4wp2O+jv9+3bB7lcjvDw8FsCTwA3FuHGSjxNiqJw6tQpnD9/HvPmzYNSqcSHH37IvJqi78vTXF1d\n4erqiuvXryMzMxNmsxnp6emYMmUK1qxZg5qaGhw+fJg5XygU4vnnn8crr7wCHx8fGAwG5t1ZHR0d\nSEtLs2XTR4wffvgBU6dOZTw++r5n6X6gg3+UlZXh+PHjSElJYebp09PTsWvXLpSWlg46SMiwK83u\n7m7s378f6enpEAgE4PP56OnpgUajgb29PRwdHdHV1YXCwkKUlZVBIBCgu7sbAoEA7u7u6OrqQk9P\nDyNEnU43pucu7wTduVpaWlBTUwN3d3cAv22vrKqqws8//4ysrCwAd3djoS0ovV6PsrIyFBUVITEx\nsd9wHwAaGhqQm5s7jK0aXZjNZmzduhUSiQQrV66EwWDAxx9/3G/3GSGE8S1WqVSoqKiAyWTCvn37\nMGnSJCxcuBAffPABVq1ahfr6eshkMkyaNAkBAQGwWCw4efIkvLy8MGHCBDQ1NTEGxKMOHTN3//79\n8PDwYMJIikSi+w6nR1vqfD4fAoGA6bsKhQI//fQTioqKmM0Kgyl72JUm7bxLBwsWCASQSqXg8Xho\naWmBVCqFvb09GhoaUF5eDi6Xi6lTp8JqtTKx9eiAHtevX8fFixdhMBhYC/Qm6E5VXV2NgoICTJs2\njXlSW61WnDlzBidPnoRWqx1wGCxCCJRKJWpqahilSSvO69evIzc3Fzk5OcPcstEB3e66ujqkpaXB\nwcEBTz/9NHg8HrZu3cpElwJurLQbDAZwOBw0NTWBEAKVSoXPP/8cZWVlmDlzJiIiIjBx4kQIBAIY\njUb8/PPP6O3txYQJExAQEICmpibs378f//73v6HVam3c+uGHVlr5+fmQy+VwdnZGVFQUYmJiIBaL\nB+RFczP0CIAeLdnZ2UGv1+Ozzz5DQUEB4wExWGU87KHhgBvbJydPngw+nw+FQgGxWIwFCxYgJycH\n3d3dCAoKYqKuu7i4IDk5GWVlZeju7oanpydcXV2ZyEVarXbMRAsfLBRFoaenBxRFITQ0FN7e3gBu\n+GEePnwYmZmZzM19r45CW05eXl6Ij4/HxIkT+ynMffv2YdeuXbh69eqYmXOm5Ua/PdLb2xtJSUnM\nxgq1Wg2z2Qy1Wg2FQoG6ujpmdxaHw0F7ezsUCgWuXr2KyspK5l3yFy5cYF7xGxYWhqtXryItLQ0H\nDhxAdXX1mBlZ0f23vb0dOp0OXl5eiIiIgEKhwLVr16DX6/v5HN+tHPo8Ozs7zJw5E2vWrIG9vT2+\n+uorpKWlobm5+b4j6Y+I0pTL5fD29obJZIJGo4FUKoWzszOqqqpgb28PJycn5tWldADh+vp6cLlc\nODo6oqenB+Xl5bhy5cp9v6t4LEC/JoT2e/X392d81aqqqlBRUYH29vYBKU3a53PKlClYsWIFvL29\nYTabceHCBezfvx979uxBSUnJCLVs9EAvqDU3N0OpVMLLywuLFi2CXC6Hq6sr4z6nUqnQ1dV1i5x1\nOh2uXbuG2tpaaLVaODs7IyAgAMnJyRAKhcjLy0NaWhrS09OZYMdjCYqioNVq0dzcDK1WCw8PD4wb\nN44JmDIQq5tWmI6OjkhMTMTKlSvh6emJH3/8EV988QWamppgsVjuW48Mu9Lkcrnw8PBAb28vzGYz\npFIpBAIBE23cz88PFosFHR0d4HA4EIvFKCkpYQLcdnd3o7GxEa2trdDr9cNZ1UcGnU6Huro6dHd3\nM6+4oCfA1Wo18254evh+uySVSjF+/HisWLECCQkJUCgUKCgowDfffIMffvgBNTU1tm6mzaCjszc2\nNqKyshJOTk6IiorCrFmz4OHhAalUyiwGSSQSZgpKJpPBx8cHERERmDp1KpYtW4ann34aEyZMQE1N\nDX766Sf8+9//xtmzZ/vt8Bpr0GsXV69eRXNzM4KCgjBu3DhIJBLGD5YOrN13mo7L5cLBwQFyuRyh\noaFISEjA0qVLIZPJcOjQIfzjH/+AUqm8r/nRfvUDMKy/iq+vL3x8fGA2mxnlR8d77O3thZeXF+zt\n7aFUKtHQ0AAulwuj0dhvYh0YusCkYwVafjExMVi7di1mzJgBLpeLs2fPIi0t7bbbTmn3F6FQiIiI\nCKxYsQIxMTFoaWnB4cOH8fPPP/dbiBvrvwc9ROTxeEhMTMTGjRsxfvx4SCQSGI1GNDU1MUN0tVoN\nkUgEf39/hIeHw83NDUajEVeuXMHhw4fx448/9ouZwMr2t/l4mUyG5557Do8//jgAoLKyEhcvXkRd\nXR26uroYxSkSieDu7o6IiAhMmjQJLi4uuHTpEg4dOoRz584xZT+obIddaW7evBkAcO7cOZSWljIb\n86OiohAbGws+n4+LFy+itLQUGo3mRqVYBTkk9JWjv78/5s6di6SkJEgkEly4cAEKhQIajQZWqxU8\nHo9ZpPP09IRMJoNCoUB2djYKCwv7OWGzi3C/0ffhzuVyERYWhgULFmDRokWIjo6GWCyGQCBg3Fq6\nu7tRX1+PzMxM7Nu3D/n5+cyD62ZDgaW/THx9fTF37txbNgrQ7l705ozOzk5kZWXhwIEDqK+v7xe+\ncChkO+xKk4WFheVRYth3BLGwsLA8SrBKk4WFhWUQsEqThYWFZRCwSpOFhYVlELBKk4WFhWUQsEqT\nhYWFZRCwSpOFhYVlELBKk4WFhWUQsEqThYWFZRCwSpOFhYVlELBKk4WFhWUQsEqThYWFZRCwSpOF\nhYVlELBKk4WFhWUQsEqThYWFZRCwSpOFhYVlELBKk4WFhWUQsEqThYWFZRCMqNLMysrChg0b7nh8\n+/bteP755++7/Lfeegvffffdfed/WBkJuRqNRqjVaqjValRWVuKzzz6Du7v7fZfJwvKwMqoszeTk\nZKSnpz9QGexLqW5lKOS6Z88eODk5wdnZGU888QQ8PDxQVFQEuVw+RLUcfdTV1UGv10Oj0aC9vR2H\nDh2Cl5fXXfPweDy0trZCJBI98HXVajU6OjqQk5ODTZs23Xd5o501a9bg3Llz0Gq1aGxsxJEjRzB9\n+vS75qmsrERwcPADXXfevHnIzMyERqNBa2srioqKsGXLFvD5/LvmGzVKc8KECVCpVGhubrZ1VR4p\nhlquVqsVVVVVSE1NRVtbG/74xz8OSbmjEUIIFi9eDEdHR3h6eqK1tRVbt269a56ZM2eiuLgYBoPh\nga/r5OQEf39/fPTRR/jTn/6Ef/3rX/dd5mhl8+bN+OSTT/Dee+9BLpfDz88P27Ztw9KlS++YJzAw\nEBwOBzU1Nfd93VWrVuHHH3/E999/Dz8/P8jlcqSmpsLHxwe+vr53zcu776sOMYsWLcLRo0dtXY1H\njuGSKyEEP//8M+bPnz/kZY8m6NfEms1m/PTTT/jb3/521/MXLVr0wFZ93+vqdDocPXoUSqUSBQUF\n+Otf/4rKysoHLn80IJFI8O677+LZZ5/FoUOHmO8zMjKQkZFxx3yLFy9+YBl//PHHeOedd7Bjxw7m\nu6tXr+L111+/Z95RY2neTRBSqRTbt2+HQqFAeXk53njjDQQEBMDX1xdfffUVfHx8Rri2Dw/DKdfr\n16/D2dl5OKo96hCJREhNTUV+fv5dzxuuh1RhYSEaGxvx+OOPD3nZtiIhIQECgQAHDx4cVL4HlXFY\nWBi8vb2xf//++8o/KpSmVCpFeHg48vLybnt84cKFKCoqQlBQEFasWAEXFxfk5uYiPT0dxcXFaGxs\nHOEaPxwMt1y9vb3R2dk5HFUfNRw8eBAdHR1Qq9WYN28e/vrXv97x3MDAQHC5XFy9evW2x6dNm4bM\nzEw0Nzfj2LFjWLVqFWQyGR5//PF7DvuBR+8h5eLigvb29kGtQwiFQsTFxeHUqVO3PR4eHo7Dhw+j\nubkZOTk52LBhA1xdXTFp0iTs3LkTAODq6goAaGlpYfKlpaWhs7MTOp0Oa9euvWc9yEilrKwssmHD\nhlu+T0lJIWlpaQ9c/ltvvUW+/fbbEWvPaEm2kuuFCxfIRx99ZPP2D1eqra0ls2bNYj6vWLGCtLe3\nEzc3t9ue/8orr5BPP/30juV9+umnJDo6mnA4HJKcnEzS09OJUqkkx44dI9HR0f2uO3v27FvyKxQK\nsmnTJpvLZajS/PnzidFoJBRFDTjP4sWLycGDB+94/N133yUzZ84kFEWRGTNmkL179xKlUklycnJI\nYmIiAUDCw8OJxWIhfn5+t+Q/ffo0Wb9+/V3rMCosTXY+c3gYSrnSc2wcDgcRERHYs2cP3N3d7znH\n97BDtxu4YXX29vZixowZtz33XvOZr7/+OkpLS2G1WpGRkYFFixbB3d0dCxcuRGlp6V3rERcXBy8v\nL+Tm5t5fQ0Yh+fn5MBqNWLFixYDz3EvGb7/9Nk6fPg1CCHJzc7F69Wq4u7vj8ccfx6+//goAqK6u\nRlNTE5588sn7qveIK83bmeILFizAsWPHRroqjxTDLdfVq1dDo9FArVbj4MGDaGtrw+TJk6FUKoek\n/IeBZcuWwcnJ6bYLMUKhEFOmTEF2dvaQXlMsFmPx4sXYvXs3du7ciYqKiiEt35Z0dXXh7bffxrZt\n27Bs2TIIhUJwuVwsWLAAH3744W3zJCcnD4khsGXLFrz99tvYuHEjHB0dAQAhISED9j0eMXO8sLCQ\nLF26tN93cXFxJD8/3+ZDhYc5sXIdnlRbW0t0Oh3RaDRErVaTixcvktTU1Nueu2jRIvLzzz8P6XXV\najXp7Owkubm55MUXX7S5PIYrPfXUU+TcuXNEq9WSpqYmcujQITJ16tRbzouMjCQXL14csusmJSWR\n7OxsotFoSGtrKyksLCSbN28mQqHwXnlHRjCRkZFEp9MRHx+fft/HxcWR+fPn2/yHe1gTK9fRkT7/\n/PNHWrGNhrRlyxby4Ycf2rweGImLfPjhh6ShoYG8/PLLtm7sI5VYuY6e9PzzzxO5XG7zejzKaeXK\nlSQsLMzm9aD+/z8sLCwsLANg1OwIuhcURYGiKBBCbrvoQVEU7OzsEBwcjMmTJ8Pb2xvNzc0oKChA\ndXW1DWo8OqBllpKSgpdeeglxcXFoaWnB4cOH8emnn6KxsZHdrz8A8vLyEB0dDXt7ewD9V9Vv5m7y\npPtvb28vTCYTjEYjtFotOjs70djYiLy8PJw4cQKVlZUwmUz3LO9RhJYtIQQURWHOnDlITk5GWFgY\nKIpCe3s7FAoFFAoFVCoV9Ho9LBYLeDwexGIxnJ2d4e/vj4CAALi6uqK3txeXL19Geno6srOzYbVa\n+11j0PXDQ2Rp0gpAKBRCLpdDJpNBIBDAarVCp9MhIiICPT090Ov16OrqQltbG5qammxdbZtDURTe\nfPNN/OEPf4CLiwssFguUSiV2796Nf//736iqqrJ1FUc96enpmDJlCuzt7cHj8cDn8++oOM1mM8xm\nc78bkn7o83g8cLlccDicWwyA7u5uNDU1oaqqCjk5OThx4gTKysrGlNKkZWpvb49x48YhJSUFwcHB\naG9vR1VVFerq6tDe3o729naoVCoYDAaYTCZYrVZwOBzY2dnB3t4eMpkMbm5ucHV1RVBQEMaNGwdn\nZ2fU1NRg7969qKyshF6vBzB4xTnqLU1aUTo4OCAqKgrBwcEQiUQghKCnpwcqlQpdXV0YP348BAIB\nSkpKUF1dDa1Wa+uqjxoIIeDz+Uz0Fi6XC29vb6SmpqKjowNGoxH19fXMuSy3snv3buTm5kIsFmPu\n3LmIi4tjjt1stZw9exYFBQXQ6XSMcqQoCnw+HxKJBJ6enggJCUFQUBAcHByYMuzt7REaGoqgoCCE\nh4fDy8sLe/fuxdmzZ0e+wTaAlqO3tzemT5+OxMREeHh44NKlS8jPz8fFixfR2tp6y8MI+M0qNZvN\n6OrqQmtrK6qrq0FRFDw8PDBx4kRMmzYNMTExeP7555GdnY28vDw0NjYyOmagjGqlSXc0Ly8vTJs2\nDfPmzYNMJkNzczMuX76M69evo729HRKJBN7e3vj1119ZhXkTdIdoaGiAQqFAVFQUgBudzNfXFykp\nKVCpVNi3bx9UKhWrNO/A999/D0IIxGIxHB0dMXny5Dtamjk5Ofjss8+gVCoZ+dN92dHREQEBAZgy\nZQpmzpyJKVOmwN/fv19+LpeLsLAwODk5QSwWo62tDbW1tSPRTJtByzIgIADz58/HrFmz0Nvbi507\ndyIzMxM6nY6RY1+595Uv/ZnD+c39nBCC5uZmNDc3Izc3F/Pnz8fKlSuxcuVKODs749ixY4zBMFC4\nAN550AYPBxRFgcvlIigoCOvWrcPmzZthZ2eHAwcOYMeOHcjMzERjYyO8vb2xZMkSlJeX48yZM+jq\n6gLAWkw0tKVjsVjg6uqKqKgo8Hi/PSs9PT1hZ2eH5uZmJtQWK7tboW9KOzs7JCUlIS4urt+N2pec\nnBwUFBT0G/7R85h6vR5NTU0oLCxEUVEReDweYmJiIBQKGYVAl+fg4ABvb29YLJY77rV+VOByuZDJ\nZFi/fj2WLVuGhoYG/M///A/q6+thNBphtVphtVoB/NY/KYqCk5MTXF1d4ezsDAcHB1AUBaPR2G/q\ng54W4fF4aG5uxqlTpxAbG4vZs2dDJBKhoqKCyTNQbL6Ef3OiKIpQFEU8PDzIJ598QlpaWsiuXbsY\np1MOh0MoiiLTp08nn3zyCfn8888Jh8MhXC53UPtYx1pKTk4mZ86cIVarlfT29pLe3l5itVqJwWAg\nu3fvJt7e3jav42hNdL+SSCRk27ZtxGKxEKvVSqxWK6GhP3/wwQfE3d2dADf66s3lcLlcwuPxCJfL\nJf7+/mTPnj3EaDQyv0ffsoxGI6mvr7d5+0dCvps3byZnz54l7733HpFIJMTb25t8/PHHJCQkhPD5\n/FvOl0gkZPPmzSQjI4OUlJSQw4cPkxdffJEIBIJbfjeBQEDGjx9PPvvsM+Ll5UXEYjF5//33yblz\n58iWLVsGqzdsL7DbCZCiKPL++++TS5cukS+++IK4u7sTiqIIj8cjFEWRkJAQ8s4775AdO3YQPz8/\nRpHauu6jOYnFYrJ8+XJSW1vLKE06NTQ0kI8//tjmdRytie5bYrH4nkrz/fffZ3w279QnKYoiHA6H\nSKVSkpKSQnQ6Xb/y6P8tFgsxGAw2b/9wp+XLl5OcnBzy5ptvkqCgIDJt2jTy008/kczMTOLj49Pv\n/uZwOMTHx4ccOXKENDY2Ep1ORwwGA+nq6iK1tbVkx44dRCaT9ZMzh8Mh/v7+pKCggOzbt4/Ex8eT\nwMBA8uabb5KcnBySkpIy4LqOioAdfaGHkwkJCYiNjcXZs2exfft2tLa2MvMXPB4PS5Ysgb+/P06e\nPMmskLPDyruj1+tx5swZvPnmm7h8+TLMZjNzTC6XIykpCevWrYO9vT04HM5d3WpYHhxCCMxmM9ra\n2u7Ydwkh6O7uHuGajTyvvvoqrly5gtOnT8PFxQVr1qxBbGwsysrKmCj4dJ+Uy+VYsWIFEhISIJfL\nIRQKmVVzb29vJCUlYe7cuZDJZAB+mz7p7u7GhQsXEBsbi3Xr1sHV1ZVZB3nllVcGXNdRtxBEN3D2\n7Nno7u7G6dOnUV5ezsz1WK1WLFy4EDNmzEB9fT1OnTrFzHWw3B1CCDo7O5GRkQGKovDSSy8hOjoa\nDg4O4PP5CAoKwqZNm9De3o6CggJ2fngY6bt4YbVa+8mYno+jKAparfauUcwfJQ4dOgSlUonFixdj\n8eLFEIlEqK+vh8ViYc6h5zGnTZsGiUTCKNK+BpW7uzs2bdqEqVOnQq/XM8cEAgHCw8Ph5uaGJUuW\noLGxEUePHsXhw4fxhz/8YcD1HHVKk+48QUFBqKiowKVLl9Db28usiLm4uGDVqlWgKAr5+fm4fv06\nI7i+wmW5PVarFSqVCnv27AGHw0Fqairi4+Ph4uICkUiE+Ph4vPDCC6AoCufOnYNarQbAKs6RoK8i\nBQC1Wo3c3NxH8t1AN/P999/jzJkzmDJlCubNm4fAwEC0tLTAYDDc0vf4fD5cXFz6LZz1lRuXy0Vi\nYiLi4+NvcWQXCAQQCAQICAhAUlISqqurkZ+fz1ilA2HUKk2TyYSKigo0NDQwxzgcDubOnYuJEydi\n//79OHPmDLhcLuzt7eHk5ITm5uZ+Q06WO2O1WrFz5050dnaiq6sLiYmJkMvlsLOzwxNPPAGr1Qoe\nj4e8vDxWcQ4jHA6HWfWl5Ws2m9He3o78/Hx89913Qx5ubjSSlpYGHo+HOXPmYMqUKfc1NdRXOfb1\nS74Z+uEUGxuLxMREZGVlYdeuXQO+zqhVmm1tbWhtbWXcNiiKgqOjI7Zs2QIAKCsrQ0tLC8RiMfz9\n/REZGYmMjAxYLBb25h4gHA4H6enpaGlpQUdHB9asWQNHR0dQFIVVq1bB0dERAoEAx48fZ+bVWNkO\nDbR1JBaLER0dDQ6HA4vFgp6eHjQ2NuLQoUPYuXMnKisrB+18/TBiMpkQHByM0NDQfq/0uNOW6QeZ\nb6fzOjs7IyIiAiEhISgpKRlw/lGnNOkOUl9fD4PBAB6Ph56eHkgkEiQnJyMwMBBbt25FaWkpKIqC\nRCJBeHg4mpqaWCtzENDzZhwOBxcvXsQnn3yCa9eu4c0334S9vT0IIZg9ezZcXV0hl8uxffv2fnNH\nLA8GvR14/PjxeO2110BRFEpKSrBv3z6kp6ejpqYGJpNpTMk7Li4O3t7eAIb34UyvjVAUBXd3d8TE\nxDzcSpOmrKwMIpEIzs7O0Ol08PT0xObNm9Hb24uzZ8/i2rVrEAqFkMlkzI0/WAdVFjCLaE1NTUhL\nS4NCocA777yDgIAA8Hg8RERE4JVXXoGvry/ee+89GAyGBwp2wHIDehU4JCQE//znP/Hrr7+iubkZ\n7e3t0Gq1zN71sSRjPz8/SKVSAA/WtwZjhTo7OyMoKGhQ5Y86pUkLq7q6mtlKxufzkZCQgJCQEOzb\ntw+1tbUQiUTw9fWFk5MTLly4wKz0sgweq9UKk8mE5uZmnDhxAiaTCb///e8xZcoUSKVSBAUFITU1\nFWKxGFu3bmVWNMeSFTTU0J4MtPdHY2MjM7XUN40lXF1dBxRFaigRCoWDfsPnqFOaNBqNBteuXYNU\nKsWkSZOwatUqcLlcVFZWwt3dHc7OzqAoCkqlEgqFwtbVfeiht/mpVCocPXoUFosFTz31FBITE+Hu\n7g5fX1+sXbsWVqsV3333HbP1jFWc9wefz4e9vT34fD6USiUTBg74zXAYa7K1s7MDl8sFMHKjGC6X\n229b8UAYtUqTVoh2dnaIiIhAQkICmpub0dLSAgcHB+j1ejQ2NuLatWusq9EQQa8qmkwmHDlyBF1d\nXTCZTFi4cCFcXV0hk8nw3HPPgRCCtLQ0XLp0CUaj0dbVfijhcDhwdXXF448/DoFAAIVCgebmZjQ2\nNjKRp8Yaer1+xNclzGYz4zw/UEa10iSEwNPTE6GhoTCbzfjll19QWFgIpVLJ3NAsQ0tfX8FTp07B\nbDbDzs4OS5YsgUgkgkQiwcaNG8Hn8/Hll1+irKxszFlEQ4HRaIRGo4GDgwM2b94MiqJQVFSE7Oxs\nFBYWora2llGeY0W2LS0t0Ol0I3pNnU436DeqjlqlSa/sPvbYY1iwYAFaWlrw1Vdf4cqVK+wq+TDT\nd2X9zJkzMBgMcHV1xZw5c2C1WiEWi7Fu3TpYrVa88cYb7HzyfUBRFK5fv449e/YgODgYGzduxJIl\nS7Bo0SI0NTUx0bzKy8vR29s7JhRnTU0NVCoVgAeb0xyorOh55StXrgyq/FG39xz4bf95VFQUJk6c\nCIFAgCtXrqCsrKyfhz/L8EJ3vsrKSrz33ntQKpXMdxKJBElJSYPas8vyG/SDSa1W4+jRozCbzUzf\n9vLywoYNG/DZZ59h9erVY0JhAkBhYSEaGhr63eO3u9eHYpGMdju6du0aioqKBpV3VCpNmnnz5iE+\nPh4NDQ1Mx2IZOeiO2dPTg8rKSmzbtg2dnZ1MoFc/Pz8sXLgQM2fOtHFNH16sViu6urr6TYtwOByI\nxWLExsbixRdfxLJly2xcy+FHKBSivb0d5eXlTDT14YLu19evX0d5eTmUSiUEAsGA8486pUnPjwUG\nBoyCmpEAACAASURBVGLKlCmQy+Worq5GVlYWgFuDG7AML30toh9++AF1dXXMPJtQKERISAhSUlJs\nXc2Hmr6r5X2Tg4MDYmJisHHjRhvXcPhJTU2FVCrFyZMncebMmXsaSDcHJKb/77sVVavVQqPR9Ev0\nXnaLxYK8vDxkZmZCKpXiqaeeGnBdR2ROczALBbTZPH/+fERGRkKpVOLcuXNQKBTgcDhsRCMbQHey\nmpoalJSUIDAwEG5ubgAAmUyGuXPn2riGjxZ97xcHBwc8/vjjNq7R8LNu3TqoVCpcuHABx48fR3h4\nOHx9fSGVSvu9vgK4EeKtvr6eiY9ws27p7e1FdnY2ysrKoNfrmek+gUCA6dOnIzY2FpWVlcjIyEBD\nQwOmTZuG9evX49tvvx1QXUfVQhA97HN0dMSSJUvg5eWFo0ePIjs7+5YIMCwjC30jV1RUYPbs2YzS\nFAgE8PPzs3HtHj76ztnd7c2WdECPRx0Oh4Nly5ZBpVKhoKAA7u7ueOaZZxAWFsYE3qAtyc7OTmRl\nZSEpKQl+fn7g8/n9LMz6+nps374dv/76KzQaDSNbekuwo6Mj9uzZg/z8fPj7+2Pp0qWD8tUc9uE5\nRVEQCASM0+rdzqOoG+8unzVrFiIjI6HT6VBQUMDsC2WtTNvQN0ACvWDR99jNlgDLwKAVpoeHxx2V\nZm9vLxNl6lHm888/R0REBBITE9Hb24vDhw/jwIEDCAoKgkAgACGEmZpTq9X45Zdf8N1336G6uhod\nHR1Qq9XMa3537tyJrKwsaDQaAL8N4YVCIUJDQ7F//378/PPPMJvNSExMxLhx47Bt27YB13XYLU16\nXqahoQGNjY13HKbTnUYsFuO//uu/4OnpiS+++KLfy93ZuczbQyut2z1U+kZgv3nVcSDyvDlIx7Rp\n0xgrE7gRnaa1tfWB6v8wMZDRTt+HzM39tu9DhhACmUyGVatWMdZS3/IJITAY/h97bx4V13El/n96\n72Zv9kWsEkISCKEdtFq7jB1ZluQt3mLHWeyZOGN7nJzv5JzJz/HYOWc8M4kzE3u8RM54bNmRbXkJ\n2heDjUACBFrYESCx79DdNDS9vd8fmvcCAkmAhJDF+5zzDlJ3vVevblfdqrp161Y/hYWFN7gUtx5f\nfvmltF3XYDDwr//6r/zhD3+grq5OCvMm+mULgoDFYuHVV18lIyOD5cuXExQURGNjIydOnKCkpGRY\nXddqtWi1Wnbu3MkXX3yB3W7nl7/8JRs3buSzzz7j008/HfW7TrjS/POf/8ysWbPYs2cPH374IRUV\nFcNsk2IlCg4OZseOHcyaNYtjx47x17/+ldraWkAeZV4NUTaK/zvBUwwzNvgEv5EYPEK8vLFe/tfb\n25v777+fFStW4OvrK6Vtb28ftS3odmA0Hc3gBnt5enHEBDB9+nSeeuop1q5dOyT2o3i/2+2mrq6O\n3//+9zewBLcmSqWS999/H61Wy8aNG3n11Vf5t3/7Nz777DP6+/uHDZzEv+Xl5Vy8eBG1Wi3t7rlc\nYYoByhsaGtizZw/e3t785je/Yc6cOXz55Zfs3LlzTIOyCVeawcHBBAcHo9PpRlzxEhuuj48PaWlp\nPPXUU1RVVfHWW29x+vTpKbUjYrw88MADzJs3j4CAAGn/rsPhwGazYTab6ejooKWlhcbGRpqbm2lr\na8NkMg05VmGkEahKpSIoKIgFCxawadMm1q5dS3h4OCqVCoVCQUNDA19++SXvv//+ZBX9lkQcTV4e\n91E891z0DFm1ahVLly4dFtlH/D0qKip45513OHny5KSU42bidrvp7OzkL3/5CyaTiTVr1vDKK6+w\nZ88eDhw4II0yL5ep3W6XVtov90IY/Jm4aLRmzRq2bduGRqPhk08+4eDBg3R2do5Jx0y40szLy+PA\ngQNkZ2fT3t4+bHojCAL+/v6sXr2a++67j87OTv70pz+RnZ1NT0+PrDBHQWBgIBs3biQuLg6NRiON\n5B0OB319fZjNZrq7u+nq6qKzs5POzk66u7uxWCyYzWZ6enqkfb9qtVoKyRcQEEBkZCSzZ88mOTmZ\n4OBgFAqF5Le5f/9+vvzyS+m89NuZhx9+mMjISDw9PYeceT4SK1asQKVS0dvbK63cKv7v7G0fHx/C\nw8OJj48nLi4OT0/PYdPy3t5eioqK+PTTT/nqq68wm803o4iTiiiDCxcukJGRQU9PD3fccQePPvoo\nSUlJnDx5ktOnTw/ZYDHS4vDggQD8LQTfvHnzWLp0KcnJybS2tpKVlUVubi4NDQ1jflcFl46lnDAe\ne+wxioqKqK2tlaKww9/O64iIiGDhwoWsWLECf39/yQAsbh2Tlea1Wbp0Kdu2bWPVqlXEx8fj5+eH\nSqUaUXaCIEijUIvFQk9PD52dnVIMR7VajaenJ0FBQQQFBeHn54dOp8PpdGKxWKirq6OsrIysrCwy\nMzOpqqqaEr/Rvn37WLx4MQaDQbKxXUlxOhyOITt8RJRKJWq1WjKhXD6NN5vNXLhwgXPnznHgwAEO\nHz5MR0fHlLLni/Ly9PRkzpw5PPDAA8yYMYP29nZKSkqoqamho6ODjo4Ourq66O/vl2StVCql6FF+\nfn4EBgYSGBhIbGwss2bNIjAwkJqaGnbv3k15efm4TyOYcKW5ceNGdDod9fX1tLe3SzED1Wo1gYGB\nLFq0iOTkZDo7O9m3bx+nTp0aVqFkro23t7e0dzk5OZmQkBB8fX2HNe6rjZBEmbtcLpxOJ3a7XRqp\ntre3U1tbS2ZmJkePHqWxsXFEc8vtSk5ODsnJyaOK93g1eQyWsd1ul0woonwPHz7MsWPHhmwnnAry\nHczgqbVSqWT9+vWkp6cTHx+PUqmUZFVbW0tXVxdWqxWn0yl1+P7+/sTExBAVFUVQUJBk6ti7dy9Z\nWVlDRqLjke2EK02AO++8k9mzZ6NSqbBYLLjdbvz8/AgKCqKzs5NDhw5x+vRpqbeQF33GxuDVc6PR\nyOLFi9mxYwfr1q0jPDwcnU43YiUZPMpxu904nU6cTidWq5Wuri4aGhooLi4mNzeXvLy8YYfcTaWO\nLTs7m5SUFAwGwzXPqLmSTMTOSNyt0tLSQmVlJdnZ2Rw+fJiLFy9KR1yIynKqyHckLq9jsbGxrF27\nls2bN5OUlISvr69kXxflJdZjk8nEuXPn2LdvH5mZmVLdFdNej465KUpTRkZG5nZB9kqWkZGRGQOy\n0pSRkZEZA7LSlJGRkRkDstKUkZGRGQOy0pSRkZEZA7LSlJGRkRkDstKUkZGRGQOy0pSRkZEZA7LS\nlJGRkRkDstKUkZGRGQOy0pSRkZEZA7LSlJGRkRkDstKUkZGRGQOy0pSRkZEZA7LSlJGRkRkDstKU\nkZGRGQOy0pSRkZEZA7LSlJGRkRkDE6Y0xdMnTSYTZrMZk8nE66+/ftV79u/fz7p1664r38WLF5OR\nkUFXVxft7e3k5uby+OOPX9czvwuMJO+QkJArpv/lL3/Jyy+/PO78Vq1aNeTMoNuZmpoa1qxZc9U0\n11t3d+7cic1mo6enh56eHs6cOcMrr7yCt7f3uJ/5XeGBBx4gNzcXi8VCc3MzOTk5/PSnP73qPWq1\nmra2NgwGw3Xl/dBDD5GXl4fZbKahoYGMjAyWLVt2zfuEibhqamqEO+64Y9TpDQaD0NbWJqjV6nHn\nmZqaKpjNZuGFF14QjEajAAgpKSnCrl27JqSMt9I1Vnl/8803Qlpa2rjzW7VqlXDx4sVJL/fNku2a\nNWuu+P2NqLs7d+4UXnrpJQEQNBqNsGDBAuHo0aPC2bNnBb1eP+kymKjr+eefF5qamoStW7cKHh4e\nAiAkJycL77///lXluXbtWuHgwYPXlfdzzz0nNDc3C1u2bBH0er2gVCqFO++8U/jtb397rXsnp6Jd\nft19993C559/fl15fvPNN8Lrr78+6RVhMq6xyNvX11dobm6+rvxkpfm360bU3cFKU7w8PT2FxsZG\n4emnn550GUzE5e3tLVgsFuGee+4Z873/9m//Jvz85z+/rrzNZrNw7733jvneW8ammZ6ezt69e8d9\nv16vJy0tjc8+++wGvtXtyaZNmzh69Ohkv8Ztw/XW3SthtVo5fPgwK1euvOHPvhVIS0tDq9Xy1Vdf\njfne65V5WloaOp2OL774Ysz3TqjS/OKLL+js7KSrq4vOzk6efPLJK6ZNT09n3759I34XFhbGrl27\naGhooKCggGeffZawsDBmzpzJ559/DoDRaESpVNLc3DwhZfkuIMq7s7Pzqp3HXXfddUVZazQaXn31\nVaqqqqiurubVV19l9uzZBAcH8/LLL7N8+fKJev3vLNdbd69GU1MT/v7+N/qVbwkCAwPp6OgYcrZ7\ndnY2XV1dWK3WK9a12NhYVCoV58+fH/H71NRUjh49SnNzMwcOHGDHjh0YjUZWrlzJf/7nfwIQEBAw\nLO/RMqFK85577iEgIAB/f38CAgLYuXPniOkSExPp6emhqalpxO/vu+8+du/ezbRp03jqqadITk6m\nqKiIXbt28cEHHwDQ3d2N2+0mLCxswspzqyPKOyAggO3bt18x3YYNGzhw4MCI3y1dupTe3l6SkpJY\ntWoVDoeDjIwMsrOzsdvt5OTkTNTrfye5EXX3akRERNDV1XWjX/uWoLOzk8DAQBQKhfTZihUr8Pf3\np6OjA6VyZPWUnp7O/v37r/jcBx98kOeee46IiAhef/11nnzyScrLy/nVr37FO++8c8W8x8KE2CvG\nYmN78cUXhVdfffW685RtmteW9+LFi4WcnJzrzk+2aV66blTdvZpN86c//emky2AiLh8fH8FsNgtb\nt24d9l1dXZ2wcuXKEe/bu3evsHHjxuvK+ztv07xRNqFf/OIX/OAHP+D555/HaDQCkJyczK5du677\n2bcLE2V/m6pMhDw1Gg0LFizg888/p7Ozkz//+c839Pm3Cmazmd/85je88cYbbNu2DU9PTwDmzZuH\nh4fHiPfo9XoWL17M119/fV15WywWfv3rX/PHP/6RLVu2oNfrUalUbNq0id/+9rfXvH9CepGamhqh\nt7dXMJlM0vXpp5+O2Nu0tLQICoXihuS7cOFCYe/evUJXV5fQ3t4u5OTkCA8//PCk96oTfVVXV49q\npJmXlyfMnz//uvNbtWqVcOHChUkv92TK9kbW3Z07dwr9/f1CT0+PYDKZhLNnzwqvvPKK4O3tPenl\nn+jrwQcfFE6cOCFYLBahpaVFyMnJEZ588klBpVINS5ueni58+eWXNzTvvLw8wWw2C42NjcJXX30l\nLF269Fr3Ta7AduzYIXz00UeT/sNNhSsoKEior6+/Ic+6++67hVOnTk16mSbzkuvuzb/+67/+S/jJ\nT34yqe+gZpLp7u7md7/73WS/xpTA19eXF1544bqfo1Kp2L59OwUFBTfgrb67yHX35lNUVMRf//rX\nSX0HBZe0p4zMqPD29qa+vp78/Hwef/zxK64ay8jcrshKU0ZGRmYMTPr0XMTPz49Fixbx0EMPMW/e\nPIKCgvD19cVgMKBWX3pNt9tNb28v+fn5vPbaaxw+fHiS3/rWR6FQIAgCWq2WRYsWkZ6eTmBgIHa7\nneDgYBQKBbW1tVRUVEgbESorK+nu7sbhcJCSkkJsbCzHjh3DZDKRkpLC3XffjdFoxGaz4XA4qKur\nu6IP7lRGpVIRHx/Pa6+9xqZNm+ju7ubYsWNUVVXhcDhQqVTApd9IoVCgVCpRqVTccccdLFq0CIfD\nQU5ODg888ACdnZ2TXJqJ5ciRI0RFRaHX6yVZDJaL+Hfw5wqFArfbjcPhAC55HWi1WikN/E224r8H\n/xX/XV9fz7vvvsu//Mu/jOpdJ11pKhQKNBoNaWlp/P3f/z2LFy/GaDQOEYyISqXCx8eHJUuWMHPm\nTI4fP05fX9+w5w1mPB7/txOCIODj48OGDRuYN28eDoeDjo4O0tLSmDlzJh4eHtKOLbvdTldXF01N\nTbS2ttLQ0IBGo8FqtSIIAmlpaWzbtg2VSoUgCLjdbqxWK/PmzZvsYt5SiHXQ39+f5cuXs2DBAlQq\nFXl5eXz00UeUlZXhcrmGpBcduRcsWMDixYsBqK+v58svv7xtndsHEx4ezrRp09DpdKNKLwgCSqWS\noqIivvzySxoaGkhLS+PRRx9Fq9UiCMKYHNfdbveo006q0hxcKIfDgdlspre3V/KxvBxRARoMBnQ6\nHWq1WqpsYqHHKqzbGbExrl69mpkzZ2K1WnG5XCxevJiIiAhqamqora2VQmwlJCQQFhZGVVUVfn5+\nzJgxA51Ox8WLF3E6naxYsQIPDw+sViudnZ10d3djMBiIi4ub7KLeciiVSsLDw1m9ejXBwcGYzWa+\n+eYbTp06RUtLCzC0oarVapxOJ/feey/Tpk3D4XBQWVnJwYMHp0THLwjCuMrZ1NTEwYMHKS4uRqlU\n8v3vf3/c+Y+Wm6Y0xWmi+O/BOBwOTp06RX9/P+Xl5SxevJg5c+YQEhIiDddFBEGgoqKChoYGBgYG\nhjxHrVZjMBjw9PTE29sbHx8fDAYD2dnZE1/AWwxxlD59+nQWLlxIc3MzfX19bNiwgTlz5pCXl8fh\nw4c5efIk9fX1+Pr6smLFCtauXcu+fftwOp1873vfY/r06YSEhPDDH/6QoKAgzpw5w4wZM1AoFJhM\nJrRaLYWFhZNd3FsGsZ57e3szZ84cFi5cCEBZWRknT56kp6dnSFrxr0KhICYmhuXLlxMTE0NTUxP5\n+fnU1tZOSjluNpfrhqsNfAYruMFT8ZHuH81zxFnTaLkpSvPyqbZoyxEV3MDAAHa7neLiYsrLywkN\nDeVHP/oRGzduJCYmBr1eL/VEdrudw4cP09LSQnh4+BA7h4eHB+Hh4URGRhIdHU1YWNiUVppKpZLN\nmzdz4cIF3G43K1euJD4+nj/84Q/8+c9/lmxBCoUCm81GVlYWISEhpKSkcPDgQY4fP05RUREqlYqn\nn34am80mKWBfX19iYmIoLy9n9+7dk1zaWwexnkdHR7N69Wri4+Pp6+sjMzOTiooKbDbbsEaqUqmw\n2+3ce++9JCQkoFQqOX36NPv375d+o9udsSitwdyoWeUtN9IUX0ilUuHl5SVFbVm2bBmrV6+mrKyM\niooK/P39MRgMOJ1Ozp07h5+fHwaDgejoaKkyOhwOlixZwoIFC/Dy8sLDwwNvb2/0er1kJ3K5XDQ0\nNHDkyJEp3aA9PDwIDQ3l9OnTPPjgg8TGxvLKK6+QkZEhKdXB06L29nbeeustNm7cyKpVq+jv70en\n02E0GsnIyOCJJ57g5Zdf5uDBg7S3twOyzfhy3G43Go2GuLg4kpOTcbvd1NfXc/jwYSwWy4jTULFu\nb9y4kaioKHp7eykrK6OkpGSSSnHzcbvdQ2QzWmV4+brHeLmllKaHhwcLFy5k1apVzJkzBz8/P/R6\nPaGhoXh4eCAIAitWrEAQBDQajWSnVCqV6HQ6DAaD1Nu63W6USiWzZs2ir68Pi8VCV1cXpaWlNDY2\nUl9fT2VlJRcvXqSrq4u+vj56e3snuoi3HAqFAr1eT3JyMrW1tWzevBk/Pz/27dtHZmYmarUal8uF\n2+2WKpyvry/R0dFotVpycnIke6bNZiM4OJikpCTOnj1Lbm7ukIUJpVI57lHC7YYoi/j4eNasWUNS\nUhJWq5Xs7GyKioqw2+3DFINCoUClUvHQQw8RGxuLRqPh0KFDHDlyhP7+/kku0c1jsjvfW0pppqam\nkpaWhp+fHwUFBTgcDtauXcuKFSvYuXMnmZmZ9PT0SAs6g10LLncdEAQBl8uF0+nEbrdLV39/P319\nffT392OxWOjr68PpdE500W5JRHmp1WrCw8PRaDTEx8dTUFBARkaG5G0wuJIoFArCw8NZsmQJR48e\nZenSpQBotVoMBgN+fn4EBgbyz//8zzQ1NeFyuYbYg2QuIXbqM2fOJDExEY1GQ01NDUeOHMFqtY7Y\nuSiVSjQaDffffz+hoaHYbDaKioooLS2dUrIVR5pj5XKb5ngY6yLUhCvNxsZGjh8/jtPpxO12M3/+\nfGJjYzGbzXz66aecPHlySEO+3Dg+kguR2+0eUgHFdJcXfvDi01RClIdarSYuLg673U5ZWRkXLlwA\n/mY/EmUbEhLC9OnT0Wq1WCwWFi1ahMvlYmBggKioKKKiosjPz6ewsFAeVV4Bsa5NmzaNtLQ0Zs2a\nRW9vL2fOnCEnJ0eqm5fXT4PBwPLly5k7dy4eHh58++23FBQU3PZ+mZcj2zQHUVlZSWVlJZ6enqxf\nv567776b+Ph4zp49S3l5ueQDKHIjldxUVJgibrcbm81GQkICZWVlNDQ04HQ6h60qajQaEhMTiYyM\npLKykuTkZHQ6HU6nE7VaLU3ZP/74Y+n+qSzXq6FQKEhMTGTBggUEBARQXl5Obm4uTU1NqNXqEVd9\nfX19ue+++wgICMDpdJKVlUVJScmUmymNt05NhtK8KfE0FQoFc+bMYdu2baxbtw673U55eTl2u12a\nhl8P4uhTbsyXEM0YPT09hIaGUl9fT1tb2zDXDIVCQXx8PAkJCbhcLpqbm9mwYQM9PT0MDAwQFxeH\nv78/JSUlfPPNN7LCvAKiXHx8fFi8eDGxsbH09fVRWlrK8ePHpZ0rl6PX64mLi2PNmjUYDAZqa2sp\nLCyU/DinEuNtvzdiIWisLkcTrjQVCgVarZZ7772XDRs2SIsQ4vEUMjcWseI5HA4uXLiASqWipaWF\nnp6eYfbioKAgduzYgUajobS0lEWLFmG1WtFqtTgcDqZPn47VaiUjI0NaNJKV5pVJTExk7dq1REVF\n0drayqlTpzh37hwqlWpIXRcHCaGhoaSnpxMcHAzA559/zrlz57DZbJPy/pPJZOuCW2qk6Xa7WbNm\nDcuWLSMoKAhBEHA6nbS0tOB0Ose9E0Dmyogyrq+vp6qqivj4eKZNmyYtoqlUKmbNmsVrr72GSqWi\nsLAQHx8f5s+fz7fffoter2fBggWEhIRw7tw56eTKya7YtyqiLX7p0qWEh4dLPscnT56Uvh+MODqa\nNm0a6enpGAwGent7ycnJkVy5phrj1QHXsxA0WPfcUjZNuHQkgLiLRKxgN2LVS2ZkRPm63W5KSkpY\ntmwZs2bNorq6GrvdTmhoKKGhoeTm5pKVlcXMmTOJioriq6++YuHChfT09DB79mwaGhrIy8uTzCiy\n0hyOqAATEhK4++67iYiIoK2tjfz8fE6fPi1tjxQRfWOjo6NZuXIlERER2O12/vKXv1BSUjKl3IwG\ncz3T88ufI/69fGZ0edrLdxqOlglXmvHx8cydO5eAgAAAyS8tKChI2hkkc+MQK4JYaaqqqtDpdPT1\n9WG32/Hw8KCyspL9+/dz4cIF5s+fT0BAAMXFxXR1dREUFISXlxcBAQHs3buX48ePyzOBqyBGkFq2\nbBnTp09HoVBw5swZioqKsFqtw+z1YkOOj4/njjvuwMvLC7PZzMGDB+ns7JyyHdP1rJ4PjoY02HXx\nWoMycaTpcrmw2+2jzvOm+GmGhYWh0Wikz/R6PXPmzEGr1U509lOKwSvjSqUSp9PJqVOnCA0Npaen\nh9raWgYGBujs7EStVjNnzhzCw8Oprq6mo6ODlJQUXC4XqampWK1WampqMJlMaDSaKbOdb6yI/rBb\ntmzB39+f7u5uTpw4QUlJybAFIFFhhoSEMH/+fGbNmsXAwAA5OTkUFhZO2VEmXP9I0+1209XVRXFx\nMRqNhv7+fhwOh+TL7XA4cDgcDAwMSJf4XVtbG6dOnRp1nhOuNFNSUvDy8hoyVNbpdCQlJREeHk5X\nV9ewwBsyY0f0+QsODiY4OBhvb288PDyw2WzMmzcPi8WCw+GgqamJyMhI4uLi8PHxoa2tDaVSyZo1\na1i6dKnkplRRUUFMTAyLFi2ioqKC5uZmeSFoBAwGAwsWLGD58uXodDoKCgqkFfDLlaZo4khMTGTp\n0qUYjUba2tr46quvaGpqmnJuRoMZHCpvPDgcDsrKynj33XdRKpVYrVZsNhsDAwPSX/HfYhxY0Xfc\n4XCMaefghCvNadOmSfHtAMnpOiwsjNWrV9Pc3ExzczMwtf0qrweFQoGnpyezZs1i/vz5JCcnM336\ndMLCwmhsbCQmJgar1Up0dLQ0JcnMzOSTTz4hMDCQBx54gLVr16LT6YiNjcVms9Ha2sqMGTPo7++n\nra1NVpojoFQqCQwMZOPGjXh5edHb20tmZibV1dXAyAtAHh4ezJ8/n5SUFABqamrIycmZ8j6w1zvS\ndLlcNDY28vXXX0uz2ss3yIgzMB8fH3Q6HTqdDg8PD1QqFe3t7aMO7DPhStPLy2tE26VKpeJHP/oR\np06dorW1VV5Fv07S0tJIT0+nv7+fpqYmpk+fTkZGBqdOnWLjxo3U1tZSWlrK9OnTWbx4MW+//Tb9\n/f3U19djNBrp7u7Gw8ODF154gX379vHKK69QWVk5JI+pam+7EgaDgcTERB588EE0Gg0NDQ18/fXX\n1NXVodFohihClUqF0+lk0aJFLFy4kKCgIBoaGvjrX/9KeXn5lK/74x1pigvKarWaFStW8Ktf/YqQ\nkBAUCoUUy0Kj0aBSqVCr1ahUqiEL0QqFArPZzMmTJ7nzzjtHleeEK83m5uYr2sOmT5/O9u3bJVuE\nvEI7PiIjI7nrrrv49ttv0Wq1zJ8/n507d3L48GHsdjtFRUVs2rQJPz8/Dh8+jKenJwsWLKCoqIiA\ngABCQkKkrZR2u5033niD+vp6qYee6g36SgQHB7Ns2TI8PT1xOBycOHGC9vZ2aZuvqAjEBux2u0lL\nSyM5ORmtVktTUxN5eXmSR8lUlvP1OrdrNBqCgoKYPXs2np6ekkyvFl9z8Ox3LIvSE640q6qq6O/v\nHxZ4Ay4Z0e+55x7a29uxWq3U1tbKinMcPPLII5w9exa1Wo23tzenT5/m66+/luw0jY2NtLW1oVar\nsVqtNDQ0EBISgkajYeHChdK/Z8+ezb59+6ipqZFWE6dyQ74aer2euXPnsnXrVulsn3Xr1hEewy65\nYQAAIABJREFUHs758+c5f/485eXlVFdX09LSgt1uZ/bs2ZK86+rq+Prrr6dU+LerMTgIzFgYrASV\nSqU0mhzrCQ5j2ZU44UozMzOTHTt2EBERIRVmMBEREezYsYOBgQF27dpFY2OjrDjHyIwZM8jNzSUu\nLo6+vj6ys7Pp7u4GLlUqp9OJy+WSwu4pFAp6enqIiIggMDCQ8PBwyZb59ttvYzab5W2p1yA0NJSF\nCxcSFxcnTb+jo6MJDQ1lwYIFdHR00NraSltbG21tbdTW1jJjxgwWLVqEp6cnhYWF5OfnYzabp/wo\nE8Y/PR/JZjmeZ9xSSvPcuXMUFxcTExMzxFdTrCRKpZI5c+Zw//3343A42LNnDw0NDWOeGk7limex\nWCTjd0tLC/X19SiVSlwuFwqFAn9/f/z9/XE4HGg0GsLCwsjPz2fhwoXo9XpCQkIICgri2LFj5Obm\nTulV3NGgVqtJSkpi1apVQxY5VSoVHh4eeHh4EBYWRlJSkhQ4pbGxEU9PTwIDA+nq6qKoqIiSkhL5\nTKv/43oXgi7fMDPSdPxyrub4fjUmXGn29fVx6NAhEhIS8PPzG+J8Cki99Lx58/D09ESr1bJnzx7q\n6+sZGBi4pjIcado/1WhpaSEkJASTyURLS4u0qCau1i5ZsgQfHx9aW1uZNm0anp6e+Pn5ERMTg5eX\nF2FhYbS3t7Nr1y5p989UleVoCAgIYPHixdKpkSOFLxQ/V6lUeHp6MnPmTGnDQUVFBbm5uTQ0NAxJ\nP5UZb0d9JaU5VsYy0pzwvedKpZKMjAyOHz9OZ2fnkLiXg3tZlUrFzJkz+cUvfsGPf/xjZs6ciaen\nJyqVasTzjgcHntBoNPj6+uLj4yOdkT6VcDqdeHt7YzKZhh33GhISwsqVKzGbzdhsNpYvX86FCxdI\nT0/HarWyZMkSAgMDycrK4uTJk7Jp5BqI4d9SUlKkkwcG18vBdXNwAxYVZn9/P+fOnaOiokIKWiwz\nfpvm5Weij4exTs9vyi9msVj48MMP2b9/vzRlHElACoUCo9HIc889x7vvvsu2bdswGo3SauRgZSt+\nptPpSExM5Pnnn+fhhx8mIiLihoSL+i4hHmk8MDAg7SoR5VRXV8e7776L0Whk8+bNAPj4+CAIAikp\nKURFRbFv3z7++7//e0qP1keLwWBg/fr1rFq1ChjbtE6hUFBSUkJmZiZVVVWA7MYlMl6Xw5F8YcfD\nLWXTFHvY8vJy3nvvPZRKJQ899NCQoKyXN1alUklSUhIvvfQSjzzyCAUFBZw8eZKamhr6+voIDg5m\nxowZJCUlkZSURExMDC6Xi1//+tdYLBZgak15DAaDNCJ3u92S+4Rareahhx5ixYoVmM1mqqur0ev1\nxMbG0tnZSVpaGgcPHmTPnj3SSvtUktt4SExMZPbs2Xh5eY3JHinuDioqKqK6uhqXyyWP6gfhcDiG\nKM6ryUVMJ9qQg4ODiY+PJyYm5vZYCIJLhRwYGODMmTPs3LmTgYEBHn74Yelo3pHQ6XRERUURGBhI\nQkICGzduxGw243Q6MRgM+Pj4YDQaUavVVFZW8vvf/56TJ09KJ/5NJQoKCrj//vupq6ujrKwMs9kM\nXJq2d3d3k5OTQ0hICMHBwQiCgM1mY/v27Rw/fpxPP/2UiooKeXPBKFCr1aSnp5OSkiJ1TKNRmuI0\nvKqqiqysLC5evDjkUDsZhpjf4OpyHTzIioqK4oUXXqCvr4+IiAjpOWOty7fUQtBgzGYzhYWF2Gw2\nOjs7uffee4mOjkan0w1LKxZCXI2MjIwc8r0YZDcrK4uMjAz2798vxeecapw4cYKUlBSSk5NRqVSU\nlpYyMDAg7UU3Go3odDpp219oaCjl5eV8+OGHUjSeqSi3sRIXF8eSJUsICwsbVfrLZ1L5+fmUlpZi\nsVhkU8hlVFZWEhkZia+v75jkIi62+fr6Sp4M4zk+55ZUmuLL9/b2curUKerq6ujo6GDt2rXMnTtX\ncrC+0pRH/NzhcNDR0UFxcTFff/01hw4dorCwELhx54V812hqauKLL75g+/btrF27luTkZBoaGlCr\n1Xh6ehIUFCRVLi8vL1paWti5cyeFhYX09fXJjXcUKBQKNm3axIwZM6ToXKOpb2Ij7ujoIDMzk6am\nJnlKPgJHjhyhvr4enU43plG4aPbQarUsXryYBx98cMRB2OVcjy30pi81i4s4zc3N/Md//AcFBQV8\n73vfIy0tTeppRBsdXJraOJ1ObDYbPT09NDQ0UFRUxBdffEFeXt6Q6CRTtfErlUoKCwvRaDRs376d\nxMRE9Ho9drtdWrEVz5kvKirinXfeob6+Hpi6Mhsr/v7+3HvvvcNmPFdisFxdLhcFBQVkZ2fT1dUl\ny3wETpw4IUW6Hw/iSarbtm1Dq9VKHdPgxePBi8hiHE1BEOjt7aWnp2fUeU2Kf87gqMpZWVnk5OQw\nd+5ctmzZwtq1a0lISMDb2xulUkl/fz+dnZ1UV1dz9OhR9uzZQ11dnaQQZGP6pUapUqk4efIknZ2d\nrF+/npUrVzJjxgy8vb1Rq9Xk5eXx5ptvcuzYMQBZbmNkyZIlREdHo9frgdGPTMTZUXZ2tnQsryz7\n4YiBNMYzWxRtxm63m4GBAcmTRDzeRQwDJ/4dHCbO4XDQ3d0tzVZHgwKQuz0ZGRmZUSJ71srIyMiM\nAVlpysjIyIwBWWnKyMjIjAFZacrIyMiMAVlpysjIyIwBWWnKyMjIjAFZacrIyMiMAVlpysjIyIwB\nWWnKyMjIjAFZacrIyMiMAVlpysjIyIwBWWnKyMjIjAFZacrIyMiMAVlpysjIyIwBWWnKyMjIjAFZ\nacrIyMiMAVlpysjIyIwBWWnKyMjIjIEJV5o1NTWsWbPmqmn279/PunXrxp3Hzp07eemll4Z8FhUV\nhcvluq1PqKytrcVqtWIymTCbzZhMJkJCQq6Y/pe//CUvv/zydeUZEhLCW2+9RUNDAyaTiaqqKv70\npz8RHx9/Xc/9LnCz5f3YY4/xzTffjPv+7wIj6YfRlHvp0qVkZ2dfd/4eHh5YLBYyMjJGfc+kjzQN\nBgMLFy4kKyvrhj/7dj/1TxAE7rrrLnx9ffHx8cHX15fW1tYrpr/rrrvYt2/fuPMzGo3k5ORgMBhY\nvnw5vr6+LFiwgKysLDZs2DDu535XuNnyFvOcilyr3HfddRd79+697ny2b99OXV0da9asISgoaFT3\nTLrSXLduHcePH8fpdE72q3wnGe1I2tfXl/j4eHJzc8ed1/PPP4/JZOKxxx7j4sWLAFgsFt5//33e\neOONcT/3u8TNlLfMlUlPT7/uDgng8ccf55133iE7O5tHHnlkVPdMutJMT0+/IT3G5dzO0/LxsGnT\nJo4ePXpdz1i3bh2ff/75DXqj25sbIe+pyrXabkhICMHBwZw5c+a68omKimLVqlV88sknfPLJJzz+\n+OOjuu+WUJpX6jHCwsLYtWsXDQ0NFBQU8OyzzxIWFsbMmTOHNd4XX3yRzs5O6bpegX5X+OKLL6Qy\nf/bZZ1dMd7Wpokaj4dVXX6Wqqorq6mpeffVVZs+eTXBwMC+//DLLly8HIDAwkJaWFum+u+++m66u\nLkwmE/v377+xBbtFuZnynioMlmlnZyd//OMfr5o+PT2dAwcOXPH7H/zgBxQVFdHU1MSf//xnVq5c\nia+vL4888gg/+9nPpHSPPvoo+fn5NDY2smfPHmbPnk1ycvI133dSlWZiYiI9PT00NTWN+P19993H\n7t27mTZtGk899RTJyckUFRWxa9cuPvjggyFpX3vtNQICAqRrNIW/HbjnnnukMm/fvv2K6TZs2HDF\nirZ06VJ6e3tJSkpi1apVOBwOMjIyyM7Oxm63k5OTA0BnZydhYWHSfRkZGfj7+/Pcc8+h1WpvbMFu\nUW6mvKcKg2UaEBDAM888c9X015qa33nnnWzcuJH4+HiOHz/O7373O0pKSli7di0ffvihlO7RRx9l\n9+7dAHR1dZGZmTnq0aYwkVdNTY2wZs2aEb978cUXhVdfffW689i5c6fw0ksvDfksKipKcDqdgkKh\nmNDyTeZ1NdkOvhYvXizk5ORcd37/8i//IhQWFg77/MknnxSOHj066fK43eT92GOPCVlZWZNe7pst\n06uVW6VSCW1tbYKnp+d15Zuamiq4XC6hvb1daGpqEpqamgSz2Sw0NzdfU2dM6khzouyZIrJd8xI3\nSs7/8R//gdFo5P333yc2NhYALy8vUlJSrvvZtxMTXa+nMitWrODMmTNYrdbres4PfvADDh06xOzZ\ns5k3bx7z5s1j7ty5GAwG7rzzzqveO+FK80quAz4+PsyePfuGTEWulMft7q4x2vLdCNcXuDSFSU1N\nxWazkZ2djclkorCwEC8vL55++unrfv6tzs2W91RgrG30RshWq9WyY8cO/vCHP9DR0UF7ezvt7e1c\nvHiR//3f/x3VFH1ShuU7duwQPvroo0mfHtzuV1BQkFBfXz/p7zFVLlneE3sVFxcLCQkJk/oOKuD/\nYxIICwsjKyuLxsbGych+yhAeHs65c+coKSmZ7FeZEsjynjjUajUGg4GvvvpqUt9DwSXtKSMjIyMz\nCibdT1NGRkbmu4R6sl/gSjzwwAMEBgaiVqtxOBxUVVVx+PBhlEolbrd7sl/vO4tCoUCpVBIcHMz3\nvvc9Fi1aRGxsLEFBQfj4+ODt7Y1CocBut9PX14fFYqGzs5PGxkYqKiqorq7GYrGgVCrx8/PD09OT\nlpYWvvzyy8ku2k1BoVCgUCgQBGHMixhK5aUxinifRqNhxowZPPnkkyxatIiAgAAAuru7ycrKYvfu\n3Zw7d07K73bmyJEjREZGolQq6ezspLq6mtOnT5Ofn09TUxNKpZLAwECioqKYMWMG8fHxREREEBQU\nhJ+fH97e3uj1etRqteQ143a7sdvtWCwW2traKC8v5+OPP+bw4cP09vaOW6a3zPRcrIwGg4FNmzYR\nGhrKuXPnaG9vJzo6mlmzZnH27Flyc3MZGBi47SvRRBEYGMjKlStZuHAhcGnvuNlsxmazoVKp8Pb2\nxt/fn2nTphEdHU1YWBheXl4IgkB3dzetra20trZy8eJFqqqqOH/+PHV1ddTX109yyW4OYoNUKBRo\nNBq8vLzw9/cnICAAtfrSGMTtduN0OjGZTLS1tWG1WrHb7UMUrl6vZ+nSpfz0pz9l2bJlhISEoNFo\nAHA4HNTX17Nnzx5ef/31KWH3f++990hPTycwMBCXy4XVaqWlpYWmpibMZjMKhQJPT098fX3x9/fH\n398fT09PSUmKv8vlekH8vyAI9Pb2Ulpayqeffspnn30mxU8YK7fESFMssK+vLwsXLiQ2NpaCggJK\nSkro7u6mp6cHvV7PwoUL6e/vp6SkhN7eXmC4kGSGIzbU2NhYVq1axezZs2lsbKSyspLa2lpaW1vp\n6+tDoVCg1+vx9fUlNDSUiIgIgoOD8fX1xcPDA4VCgcPhwGKxUF9fT2VlJTU1NfT39092EW8aer2e\nhIQEEhMTCQ8Px8/PD6PRiNFoRK1WSyNQp9OJxWKhvb1dCiUnKoGLFy8SExPDww8/zJYtW9DpdEPy\nUKvVxMbGsnHjRs6cOTNkF8vtynvvvYefnx8rV67EaDRKUaQSEhKAS+18sGIU5Stuvezu7qa3txeX\ny4W3tzfh4eHExsbi7e2NUqlEoVDg7e1Namoq3t7eNDc3Yzab6e7uHvNIftKVpigIf39/0tLS2LZt\nG4cOHeLMmTOYTCYUCgWtra18++23eHp6kpqaitvtpqKiArPZPMlvf+sjyjcmJoaNGzcyf/588vLy\n2LVr14gjdrvdjtlspqGhgfz8fOCSoggICMBqtWI2m4f03mIeU6Hz0uv1LFu2jK1bt7JmzRqio6PR\n6/WoVCpg+GYKsXEPDAxgsVioqamhrKyMs2fPMn36dO666y70er2kENxu95BnhIWFsXLlyimhNL/5\n5hvJHLds2TL8/PyGKMrBday7u5v8/Hyqq6upr6+noaGB5uZmuru7cTgcBAYGMnPmTBYtWsSSJUuI\ni4vD09MTuDQLSExMZPny5ZSUlNDT0zOu+jupPk8KhULw9vYWtmzZIuzfv19obW0VnnnmGSEyMlLQ\narVDtjRpNBrhqaeeEn7+858LS5YsEQwGw229TfJGXEqlUjAajcI//uM/Crt27RKeeuqpId8pFApJ\nhuK/FQqFoFKpBLVaLRiNRmHx4sXCI488IiQlJQk6nU5QKpWCSqWacrJPSUkRDhw4INhsNsHtdkuX\ny+US7Ha70N/fL/T19Ql9fX1Cf3+/YLfbBafTKaUTcTgcgt1uF1wul/SZ2+0WHA6H4HQ6BZfLJbhc\nLqGjo0N47733Jr3cN+MS69LWrVuFvXv3ClardYiMB18nTpwQ5s2bJyiVSqkOX/4shUIhGAwG4Yc/\n/KFw7NgxoaurS3A6nYLD4RDcbrfwxRdfCGvWrBEUCoWgVCrH9K6T5qcJfzOMr1+/nmeeeYbNmzfj\n4eHB+vXraWxspK6uDovFItks3G43RUVFJCUlMWPGDOx2O42NjahUqikx0hkr4qLZY489Rnp6OkVF\nRbz++uvSyOhKMhNl7e3tzfe//31+8pOfUFdXx5EjR3A4HLjd7ikp71deeYU1a9bg6ekpjQoFQcBm\ns9HU1ERDQwMtLS20tbVhMplwOBzSwtvgEaRSqRz2mfj5YBobG8nIyODEiRM3pXyTjUqlory8HKvV\nyvTp04mMjBwy2oRLdbampob/+Z//obe3F5VKJclSqVSiUqlQq9XSAvKpU6c4d+4cOp2OxMREKbDM\niRMnyMnJoamp6bszPRcb9JYtW/jJT37CqlWrpO+0Wi3/+I//iJeXFx9//DHV1dVDCrZ79242b95M\namoqarWa48ePT5kp4mgRK1pSUhLf+973KCwslKZ5V1v5FeXo4+PD888/z5YtWygoKOCDDz7AbrdP\nWRkbDAaio6Px9PREqVQiCAINDQ18/vnn7N69m+bmZpxO5xCThUajwdvbm+joaGJjY6Up4/Tp0/H1\n9ZU6r8GIv1tTUxN79+6dElPzyxG9Na6EQqEY0vGLdXawV434mUKhoLS0lFdeeYXPP/+cO+64g4GB\nAfbu3UtxcfG4vCAmRWmKPermzZt56qmnSE1NxWAwAH8b5YSGhrJ8+XJOnTpFdXX1kPvNZjPZ2dks\nXbqUBQsW4HQ6ycvLk92RLkOhUPDss8+iVCopKiqioaFBku+V0os99jPPPMP27ds5f/4877//vmRf\nnqoYjUa8vb2lFfLW1lb27t3LH//4RxobG6+4GKZSqaitrSU/Px8fHx+MRiPh4eFs2bKF++67T6r3\nfX19VFZWUl9fT2lpKUVFRZw+fZrOzs6bVsZbBbfbjcvlumqawe5b4qjf19eXadOmERAQgMvloqur\ni9bWVkwmE01NTfT09FBVVYXb7aa9vR2bzTau97vpSlOhUODh4cGSJUt4+umnWb58OX5+fkNWxhQK\nBS0tLeTn53PhwoUhxmCR5uZmCgoKEASB1NRUnE4npaWl2Gy2KTsaEhFXwVNSUli9ejW7du2iqKhI\nmi5eDZVKRXp6Olu3bsXb25uioiIKCwun/Eh+cNkVCgWdnZ0UFxdTVVUlrZqPhLjKa7FYpPOEdDod\nRqORlStXEhcXh9vtpquri7fffpvy8nKamppobm6+Ll/C2xnRvAGXXOjmzZtHYmIiMTExhIaG4u3t\njdvtpre3VwrEUVxcTH5+PrW1tdJMYbzcNKUpNlYfHx8WLFjAM888w9q1a6VVLRG32013dze7d+/m\nk08+obKycsTnCYJAfX29ZHtbtWoVLpeLqqoq+vr6pDRTDVHOfn5+PProo+h0Ok6dOiX5UV5tlKnR\naAgPD+eJJ55g5syZFBQUUFRUJLkjTUV5ipjNZnp6enA4HGg0GnQ63bC6OxoUCgU2m42Ghgbq6uqI\ni4sDLnVW+fn5nDlz5pqjrNuda02ZtVotkZGRJCQkMH/+fNLS0khOTiY0NFRy3xLrq91up7W1lbNn\nz/L111+Tk5NDcXGxNDMYT52+qUrTy8uL+fPn88QTT7B169Zhox6n00l3dzd79+7ljTfeoKamZogb\nhkajQaPRYLPZpMWI5uZmDhw4wIMPPii5I1VXV9Pf3z8lG7kgCKjVaoKDg7n33nuprq6mra0Nh8Nx\nxXtE+Xp7e7Np0yZWrFiBXq/nxIkTnD59WnruVMZqtVJWVkZycjIGg4HQ0FCSk5MJCgqio6Pjqp3K\nYBctcYTU0dFBXV2dNLMKDAxk2rRpVFRUSJ2+bGoamYCAALZs2cLSpUtJSUmRdrGJynawXVmn0xEV\nFUVkZCTLly/nwIED7Ny5k8LCQnp6esaV/03Ze65UKtFoNMybN48nn3yShx9+eNjqodvtpqenh6+/\n/poXXnhhmMI0GAzMnDmTpUuX4u/vL93vdrvp6Ojg7bffxsPDg2XLljF9+nRUKtWUs8GJNklPT0+m\nT59OUFAQeXl5dHV1Ddk1cTliY46MjOTZZ5/Fx8eHlpYWiouLpRHqVFeaAPv27ePChQu4XC48PT1J\nSUkhPT1dWq0dTX0T5dje3k5NTc2QLZXx8fH4+PiMa3HidkesvwqFgtjYWJ577jlWrFiBVqvFYrHQ\n3d1Nd3c3JpOJvr4+aVA1WJZGo5GHHnqI1157jVWrVo1rpgA3YaSpUqlwuVwsWLCAH//4x8POVRF7\nWrPZzJEjR/iHf/gHqQcQK6FarSYxMZG33nqLsLAw/t//+39kZGQM6eEHBgb405/+xMMPPyytxJ89\ne3ZKLQ6J8goJCWH58uW43W5qampGZRsLCgoiLS2NmTNnolQqyc7Opra2Vnqu3Ijh2LFj3HnnncTF\nxREUFER8fDxPP/00Z86cGfUecfH7jo4OqqurGRgYQK/XAzBr1ix8fX1paWmRBgSy3IcjLlb29/eT\nm5vLiRMnqK2tpa+vDy8vL+bMmcPWrVuJiIiQtqbC36b9c+fO5eWXX8ZgMPDxxx+P6x0m3HE1NTVV\n+OCDD4SOjo4RnVW7urqEd999V0hMTJQcTUWHVa1WK6xbt044ePCg0N/fLzidTqG4uFh48sknBT8/\nvyFplUqlEBERITzyyCPC3/3d3wmJiYmT7rR7My/RqTc1NVU4fPiw4HA4hAcffFDw9/cf4sQ++NLp\ndIKHh4ewfv16ISsrS3C73YLT6RRefPFFIT4+XjAYDIJKpZr0sk32Jcpu7ty5wq5duwSbzSa4XC7B\nYrEIBQUFwq9+9SshNDR01A7/SqVS2Lx5s1BXVyc5uOfm5gppaWkjbjiY7PLfjEvcMLFs2TJh165d\n0sYBcWOAqC/6+/uFc+fOCffcc48we/ZsISwsTPD39xf8/PwEf39/ISIiQpg3b57w0UcfCe3t7UOe\nI9bvvr4+4eDBg8K2bduk32PU78kEO7cvWbKEv/u7v2PdunUEBgYOm8JYLBY+/vhj3n33XUpKSoY4\nDavVatatW8dPfvITVq9ejcFgQKFQYDQaiYiIwG63c/78eQYGBqR7+vr6MJvN+Pn5MXfuXMxmMx0d\nHRNZxFsGUbYzZ87k/vvvJzAwkE8++UQa0YyUNiEhgXXr1nHvvfeyevVqtFotJpOJqqoqac95d3f3\nuN0zbicUCgUmkwmTyYSPjw9xcXHo9XqCgoKIjY3F19eXCxcu0NXVdc3nwKWV30WLFhEdHQ1cMmPt\n37+f+vp6/P39MRqNOByOq9qjbyfEVe3IyEiWLFlCUlISMNRrxuVyUV5ezm9/+1sOHTpEa2srvb29\n2Gw2BgYGsNlsUrCP5uZmpk2bRmxsrOQqJk7x1Wq1FFXq/PnztLW1jfo9J3x67uvry6xZswgICBji\ncCridrupr6/n4sWLOBwOVCoVbrcbtVrN2rVrefzxx1mzZg1eXl7SPRqNhri4OKKiooY8S6FQ4HK5\n6OzspK+vj+Dg4GHBEKYCarVastf4+vqi1WqHTR3F38FqteLv78+cOXPw8fHB4XBw8OBBCgsL6ezs\npKura8o02msh7v7Jzc1FoVDQ09PD6tWriYyMZPr06WzcuJGMjAzOnz9/1eeIdba7u5uSkhLJnOTn\n50d6ejpz584lNDQUrVZLTU0Nhw4doqysbMLLdysj1teuri5OnDjBvn37sFqtV7T/KhQK8vPzycrK\nYtasWSQkJAxZIHK73fj5+ZGamkp6ejrFxcWjfpcJV5o1NTUcO3ZM6pkv3wWh1+tZsmQJZWVlZGZm\nYjabUSqVpKam8sMf/pD169djNBqHCMZsNnP8+HHy8vKGORV7eXmRkJCA0WikuLj4imeq386IFUmh\nUBAfH4+XlxednZ3D7GTTpk3DYrHQ39+Pt7e3NFL/y1/+QmZmJiaTaZJLcmtiMpk4duwYTU1N1NTU\nMH/+fMLDwykpKRmTzEwmE5WVldLvodPp2LFjBxqNBj8/P5RKJQ0NDQQEBPDP//zPE1Wc7xQNDQ3k\n5eVhMplQq9UjumcJgoBKpcLhcHD69GlKS0ulaEni92LHFRUVxbp169i1axcNDQ2jeocJV5rV1dX8\n7ne/w+1289BDDxEZGQn8rbfV6XTceeedGAwGnE4n2dnZhIaG8sILL7B69Wp8fX2HRIEZGBggNzeX\nN998k2PHjuF0Ooe4JCUkJLBo0SJMJhMHDhyYkg3f6XTS29uLQqFg2bJl7Nu3T9rmB5dGoiEhIcyf\nP5+2tjZmz55NTEwMDoeDpqYmioqKpPvlhYiRsdvtnD17lpKSEgIDA1m4cCHFxcU0Nzdf9T5xEcPT\n05OQkBA8PDxwu92Sw3Z4eLiUVhAEgoKCSE9Pn/JKU2zjLS0tlJaWAld3yRIHB7W1tVy4cGHYDFes\n23q9nri4ODZv3sy77747qneZcJcjpVJJa2srb775Jh9++KG0HW9wY9RoNNxxxx380z/9E3fddRe/\n//3vWbduHb6+vlIaQRBwuVycPn2aX//61xw9elRSmKIwYmJiWLt2LR0dHZLCnEpuR6JkaIEtAAAK\nkklEQVQs+vr6pMa7ZMkSVq9ezbRp06TGOmvWLH79618zMDBAXFwcs2bNklw3vv322yHh32RGRpSP\n2+2mpaWFvXv3cvHiRex2+4jpBweU8Pb2Zs2aNbz00kv80z/905BAHeIsweVyYbPZqK+v5/PPP78p\nZbpVGSzrzs7OUbnBDQ4jdyUTkyhro9FIenr6qN9nwkeaYi/a3NzMe++9R39/P7/4xS/w9vaW0oiL\nPikpKfz7v/873t7eUjQSEZvNxtmzZ/nZz35GWVnZEB9OlUpFdHQ0Dz74IAUFBeTn5487Tt53GbGs\nra2tHD9+nA0bNqDRaPjZz37G8uXLuXjxIv7+/sTHx/PJJ59w7tw5fv7zn5OSkoIgCLS3t/Phhx9K\nztUyV2ewGWSwc/XliPXU7Xazfv16nnjiCSnY7kg295aWFk6cOMH+/fs5fvz4lIjcPhrcbrd0BMto\n6evro7e3F6fTOUynDJ7txsTEjPqZN2VHkDhUFqPCaLVaXnjhhSFBOuDSy19phf3EiRO89NJLlJWV\nDVkJ1mq1REdHc//991NYWMjp06fp7u6ekg7CYgNubW3l6NGjPPLII0RHRxMQEEBaWhopKSm0trby\n1Vdf8dFHH+Hv709CQgL+/v5YrVZqamooKirC6XROGd/WG8G1okbBpe3DP//5z9m0aRMJCQn4+vqO\nGB6uv7+fDz/8kA8++IDm5mZ6enoks8pUR/i/oM7iqHE07dvpdNLf34/NZsPDw2PENGq1GqPROOr3\nuGnbKMV9oLW1tezevRudTsfjjz9OUFDQMFvDYEwmE99++y1vvfUWeXl5Qwy/er2eGTNmkJqaSnl5\nOadOnaKjowOXyzXlFKaIuMJbUlLCyy+/zPbt24mPj6e3t5eSkhKOHz/O8ePHqa2t5ac//SlxcXFo\nNBppwa63t3dYXEeZ8aNSqQgJCeHZZ59l69atREVFSSMe0UbvdDqlrYBqtRqTyURdXd2UnC1di/GY\n20Q3JH9//2G2TZGx7Pe/qVGOxAZdVVXFu+++i5eXF1u2bCE8PHzEhup2uykpKWHPnj0cOXJEKpgg\nCOh0OmbMmMG8efOw2WxkZmbS3d09ZXdRDG5cgiBgMpnYvXs3bW1txMbGYrVaKS0tpaysDJvNhl6v\nZ/Xq1ZK/a0VFBYcOHZrkUtx+GI1GHnvsMZ544gmMRqNUz8Xfo6CggJSUFJYuXYpKpUKj0eDr64uX\nl5esNC9D7FQG7/K5VnpR51xtSt/f3z8s/OTVuOmh4QRBwOFwUFNTwxtvvIFGoyE9PZ2wsLBh+6MF\nQaCnp4eOjg5pKiMIAlqtlri4OJKSklAqlRw+fPiaQROmGuLW0oMHDw7zj9XpdCQlJZGYmIiPjw+1\ntbWcPHmS0tLSKbXtdKIxGAzMmzePv//7v8ff31+Sf3t7O0VFRezevZvMzExefvllFi9eLClUMRo5\njG4KOlUQA3B4eHiMuKA8Unq4pBQv96IZPMDo6enh6NGjo36PSQlCLAaIKC0t5T//8z8RBIHt27fj\n7+8/JJ1KpeKOO+7A4XDQ2tpKYWEhcMm/cPny5dhsNg4fPkxzc/OUVpjiCMXhcAybZoxkNzMYDDz8\n8MOEhobicrnIycnh4MGD0qKdzPUhyjsiIkIaEIgLlxaLhYMHD/L2229z/PhxEhISmDFjhvQ7ifE3\nrVbrJJfi1kOpVGIwGKTTJEfb5q1WK93d3SN+Jx6X/Ne//nXU7zFpx124XC5UKhWlpaW8+eabuN1u\nnnzySbRa7ZBRkYeHBxs2bMBgMPDEE09gt9vZvn07jY2NfPPNN1Jwg6mqMOFSqKw5c+Zw/vz5YQ66\nlx8BoFKpCAgIYNu2bfj5+XH+/HkyMzM5ffq0PMq8wQQEBJCSkjLks7179/Lmm29y8uRJtFotISEh\nzJkzR9r0IW4BFIPWTMV6ffmMU/y3GMHLz89vTM8bSWmKnVhrayu5ublj2nE1qUf4ulwulEollZWV\nvPfeezidTn784x8Pcw3Q6/Wkpqby6aefkp2dzYkTJygsLJQiYU/FijWYt99+m/j4eN555x0++ugj\nWltbh3Uk4ggyIiKCH/zgBwQGBtLX18ef/vQnDh48OOVlOBG4XC7J00OpVGKz2cjKyqKiokKKtvPi\niy/i4eEhDSIqKipoaGiQZmNyJzYUrVY75pBuVqt12LEh4u+Rk5PDzp07x/S8ST/3XFxBLCsr48MP\nP0T9/7d3Ly2prXEYwB9LyIWGBl3EgooSLCMoooENggiCCqKCatSH6SNUEF2pwZ44MKhBkkHXQYTU\nwCJHUlkYYSux1XWJnkGs99g+nIML9q7N8flNg9DXenyV/8VoxPj4uBjOod06zWYzampqsLCwgOPj\n438ssspnnZ2dSKfTSKfTnzqkNFpgWiwWtLa2YnR0FJlMBrOzs9jY2BDDCniWv9bDwwNCoRB6enoA\nfJS2NDU14fLyEqWlpRgcHERHR4e4WamqCr/fLxZ+5SvtI3g2LQeMRuOn6ez/RSsFk2UZ0WhUvDEB\nH63YPp8Pi4uLYqVOrmf+7aEJfDy5p6cnnJ6eYnl5GZIkob+/X3x5rqoqrq6usLKygp2dHcRiMaiq\nmtd/WNmsVivC4TBubm4+tT9mF1xLkgSPx4Px8XFYLBYsLi7ix48fiEQieV2i9TtoZ393d4fd3V2M\njY2JCpHu7m7U1dXBZrPB7XaLQTQGgwFHR0fY398X3Vz59JpkD9FobGyEy+X69PPsQcK5FqJndwVF\nIhHIsoyysjIAHxcJRVEgyzLe39917Q361r3nP0ulUojH42JIQUVFBUwmEy4uLuD1ejE1NYXb21v+\nk/9keHhYDCeIRCKfxrgVFBSgsrISHo8HAwMDcDqdWF9fx8zMjBgZx7P8Pd7f36EoCoqLi9HQ0ICi\noiKUlZWhvr4eVVVV4saUSqUQDocxPz+Pg4MDJJPJb37kX08LLY/Hg5GREbS3t4tPSNmXgIKCAtzf\n3yMQCORcXqh1A9XW1orBHVrp0tvbG25ubnTNqPijQhOA6ByKxWIoLy9HOp2G3+/H9PQ0v8P8F5lM\nBk6nEyaTCa+vr1BVFZIkwWq1wm63o7OzE319fSguLsbq6iomJydxe3ubtzWtX+nl5QWhUAgul0u0\nTRYWFoqSsEQigXA4jKWlJXi9XsTj8bx8TbTQHBoaQm9vL0pKSqAoCuLxOJLJpOgCMplMeH5+RiAQ\nwOPjY07F7gaDQZx1c3MzzGYzjEYjHA4HbDYbotEozs7Ocn6sf2RoGgwGRKNR3N3d4fDwEFtbW79k\n9eb/VTAYRCKRQEtLC7q6uuB2u1FdXY22tjb09fXB5XLh8PAQc3Nz2NzcFKt8eZZfQ1EU7O3twW63\nw+FwQJIkqKqKWCyG7e1tTExMYG1tLW+XAQJ/h6bT6URTUxOsVitCoRB8Ph9OTk7ETVCbhnZ+fq6r\nIP3t7Q3X19e4vr4Wa0UKCwshyzLOz88RDAZz/l0GfIxwJyKiHLCSmYhIB4YmEZEODE0iIh0YmkRE\nOjA0iYh0YGgSEenA0CQi0oGhSUSkA0OTiEgHhiYRkQ4MTSIiHRiaREQ6MDSJiHRgaBIR6cDQJCLS\ngaFJRKQDQ5OISAeGJhGRDgxNIiIdGJpERDr8BWaZJwd/JFfbAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9af6404e10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "restore_and_display_test(graph, \"l2 reg 3h\")\n",
    "restore_and_display_random_incorrect(16, graph, \"l2 reg 1024\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "klf21gpbAgb-"
   },
   "source": [
    "---\n",
    "Problem 2\n",
    "---------\n",
    "\n",
    "Try to get the best performance you can using a convolutional net. Look for example at the classic [LeNet5](http://yann.lecun.com/exdb/lenet/) architecture, adding Dropout, and/or adding learning rate decay.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[None, 14, 14, 32]\n",
      "[None, 7, 7, 64]\n",
      "[None, 4, 4, 128]\n",
      "[None, 2, 2, 256]\n",
      "[None, 1024]\n",
      "[None, 256]\n",
      "[None, 50]\n",
      "L2 regu elems: 3\n"
     ]
    }
   ],
   "source": [
    "graph = tf.Graph()\n",
    "with graph.as_default():\n",
    "    # Input data. For the training data, we use a placeholder that will be fed\n",
    "    # at run time with a training minibatch.\n",
    "    tf_batch_size = tf.placeholder(tf.int32)\n",
    "    tf_train_dataset = tf.placeholder(tf.float32, shape=(None, image_size, image_size, num_channels))\n",
    "    tf_train_labels = tf.placeholder(tf.float32, shape=(None, num_labels))    \n",
    "    tf_keep_prob = tf.placeholder(tf.float32)\n",
    "    \n",
    "    regu_weights = []\n",
    "\n",
    "    def convolution_block(block_name, input_data, prev_depth, conv_depth, patch_size, conv_stride,\n",
    "                          pool_ksize=None, pool_stride=None, padding='SAME', hasLrn=True):\n",
    "        with tf.variable_scope(block_name):\n",
    "            weights = weight_variable([patch_size, patch_size, prev_depth, conv_depth], 20000, #patch_size*patch_size 20000 gives 0.01 stdev\n",
    "                                     name=block_name + '_weights')\n",
    "            biases = bias_variable([conv_depth], name=block_name + '_biases')\n",
    "            conv = tf.nn.conv2d(input_data, weights, strides=conv_stride, padding=padding)\n",
    "            hidden = tf.nn.elu(conv + biases)\n",
    "            #lrn\n",
    "            if hasLrn:\n",
    "                lrn = tf.nn.local_response_normalization(hidden, depth_radius=5, alpha=0.0001, beta=0.75)\n",
    "            else:\n",
    "                lrn = hidden\n",
    "            #pooling\n",
    "            if pool_ksize is None:\n",
    "                return lrn\n",
    "            else:\n",
    "                pool = tf.nn.max_pool(lrn, ksize=pool_ksize, strides=pool_stride, padding='SAME')\n",
    "                return pool\n",
    "            \n",
    "    def fc_block(block_name, input_data, input_nodes, hidden_nodes):\n",
    "        with tf.variable_scope(block_name):\n",
    "            weights = weight_variable([input_nodes, hidden_nodes], input_nodes, name=block_name + '_weights')\n",
    "            regu_weights.append(tf.nn.l2_loss(weights))\n",
    "            biases = bias_variable([hidden_nodes], name=block_name + '_biases')\n",
    "            hidden = tf.nn.elu(tf.matmul(input_data, weights) + biases)\n",
    "            return tf.nn.dropout(hidden, tf_keep_prob)\n",
    "            \n",
    "    def model():        \n",
    "        #data = convolution_block('conv3', data, 48, 64, 3, [1,1,1,1], padding='SAME', pool_ksize=None, hasLrn=False)\n",
    "        #shape = data.get_shape().as_list()\n",
    "        #print shape\n",
    "        #data = convolution_block('conv4', data, 64, 64, 3, [1,1,1,1], padding='SAME', pool_ksize=None, hasLrn=False)\n",
    "        #shape = data.get_shape().as_list()\n",
    "        #print shape\n",
    "        #data = convolution_block('conv5', data, 64, 48, 3, [1,1,1,1], [1,3,3,1], [1,1,1,1], 'SAME', hasLrn=False)        \n",
    "        #print shape        \n",
    "        data = convolution_block('conv1', tf_train_dataset, 1, 32, 5, [1,1,1,1], [1,2,2,1], [1,2,2,1], 'SAME', hasLrn=True)\n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape\n",
    "        data = convolution_block('conv2', data, 32, 64, 5, [1,1,1,1], [1,2,2,1], [1,2,2,1], 'SAME', hasLrn=True)        \n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape\n",
    "        data = convolution_block('conv3', data, 64, 128, 3, [1,1,1,1], [1,2,2,1], [1,2,2,1], 'SAME', hasLrn=True)        \n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape\n",
    "        data = convolution_block('conv4', data, 128, 256, 3, [1,1,1,1], [1,2,2,1], [1,2,2,1], 'SAME', hasLrn=True)        \n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape\n",
    "        data_flat = tf.reshape(data, [-1, shape[1] * shape[2] * shape[3]])\n",
    "        input_nodes = 2 * 2 * 256#(image_size / 2) / 2 / 1\n",
    "        data = fc_block('fc6', data_flat, input_nodes, 1024)\n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape \n",
    "        data = fc_block('fc7', data, 1024, 256)\n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape \n",
    "        data = fc_block('fc8', data, 256, 50)\n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape \n",
    "        return data, 50\n",
    "    \n",
    "    def model_prob1():\n",
    "        shape = tf_train_dataset.get_shape().as_list()\n",
    "        print shape        \n",
    "        data = convolution_block('conv1', tf_train_dataset, 1, 32, 5, [1,1,1,1], [1,2,2,1], [1,2,2,1], 'SAME', hasLrn=False)\n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape\n",
    "        data = convolution_block('conv2', data, 32, 64, 5, [1,1,1,1], [1,2,2,1], [1,2,2,1], 'SAME', hasLrn=False)        \n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape        \n",
    "        data_flat = tf.reshape(data, [-1, shape[1] * shape[2] * shape[3]])\n",
    "        input_nodes = 7 * 7 * 64#(image_size / 2) / 2 / 1\n",
    "        data = fc_block('fc6', data_flat, input_nodes, 1024)\n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape \n",
    "        data = fc_block('fc7', data, 1024, 256)\n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape \n",
    "        data = fc_block('fc8', data, 256, 50)\n",
    "        shape = data.get_shape().as_list()\n",
    "        print shape \n",
    "        return data, 50\n",
    "            \n",
    "    # output layer variables\n",
    "    data, exit_nodes = model()\n",
    "    weights_o = weight_variable([exit_nodes, num_labels], exit_nodes)\n",
    "    biases_o = bias_variable([num_labels])            \n",
    "    #output operation\n",
    "    logits_o = tf.matmul(data, weights_o) + biases_o\n",
    "    y_conv = tf.nn.softmax(logits_o) #after softmax -> output probabilities / predictions\n",
    "    #define loss\n",
    "    print \"L2 regu elems: %i\" % len(regu_weights)\n",
    "    loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits_o, tf_train_labels) +\n",
    "                        (0 if len(regu_weights) == 0 else (2.0/(3*1024)) * sum(regu_weights)))\n",
    "                            #* reduce(lambda q, p: p+q, x)))\n",
    "                    #+ (2.0/(3*hidden_nodes))*(tf.nn.l2_loss(weights_i)\n",
    "                    #+ tf.nn.l2_loss(weights_h2)\n",
    "                    #+ tf.nn.l2_loss(weights_h3)))\n",
    "    #decay learning rate\n",
    "    global_step = tf.Variable(0)\n",
    "    learning_rate = tf.train.exponential_decay(\n",
    "        0.1, global_step * tf_batch_size, train_dataset.shape[0] / 1, 0.95, staircase=True)\n",
    "    #Optimizer\n",
    "    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)\n",
    "    #learning_rate = tf.constant(0.01)\n",
    "    #optimizer = tf.train.AdamOptimizer(learning_rate).minimize(loss, global_step=global_step)\n",
    "\n",
    "    #define operations to measure accuracy\n",
    "    is_correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(tf_train_labels,1))\n",
    "    accuracy_l = tf.reduce_mean(tf.cast(is_correct_prediction, tf.float32))        \n",
    "    #saving mode\n",
    "    saver = tf.train.Saver(max_to_keep=20)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "session restored from ./model.ckpt-18000\n",
      "Minibatch loss at step 0: 0.267122 with learning rate 0.069834\n",
      "step 0, training accuracy 0.976562\n",
      "Validation accuracy: 0.93057\n",
      "Minibatch loss at step 500: 0.339107 with learning rate 0.069834\n",
      "step 500, training accuracy 0.96875"
     ]
    }
   ],
   "source": [
    "train_model(50001, 500, 128, graph, is_saving=True, keep_prob = 0.7, restore=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test accuracy 0.967956 ./model.ckpt-13000\n",
      "test accuracy 0.969398 ./model.ckpt-13500\n",
      "test accuracy 0.970038 ./model.ckpt-14000\n",
      "test accuracy 0.969237 ./model.ckpt-14500\n",
      "test accuracy 0.971694 ./model.ckpt-15000\n",
      "test accuracy 0.97116 ./model.ckpt-15500\n",
      "test accuracy 0.970946 ./model.ckpt-16000\n",
      "test accuracy 0.970519 ./model.ckpt-16500\n",
      "test accuracy 0.970786 ./model.ckpt-17000\n",
      "test accuracy 0.972121 ./model.ckpt-17500\n",
      "test accuracy 0.971053 ./model.ckpt-18000\n",
      "test accuracy 0.970893 ./model.ckpt-18500\n",
      "test accuracy 0.972495 ./model.ckpt-19000\n",
      "test accuracy 0.972869 ./model.ckpt-19500\n",
      "test accuracy 0.972816 ./model.ckpt-20000\n",
      "test accuracy 0.972228 ./model.ckpt-20500\n",
      "test accuracy 0.972015 ./model.ckpt-21000\n",
      "test accuracy 0.972442 ./model.ckpt-21500\n",
      "test accuracy 0.972655 ./model.ckpt-22000\n",
      "test accuracy 0.973457 ./model.ckpt-22500\n",
      "test accuracy 0.973457\n",
      "Incorrect no: 497\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAESCAYAAAB5KIfmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ns9zP8ooAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f9af5ce5c10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "restore_and_display_test(graph, \"l2 reg 3h\", display_all=True)\n",
    "restore_and_display_random_incorrect(16, graph, \"l2 reg 1024\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A good result no 1:\n",
    "\n",
    "    test accuracy 0.973457\n",
    "    Incorrect no: 497\n",
    "    \n",
    "for elu activation, l2 regu, maximum at 19000 step\n",
    "\n",
    "    [None, 28, 28, 1]\n",
    "    [None, 14, 14, 32]\n",
    "    [None, 7, 7, 64]\n",
    "    [None, 1024]\n",
    "    [None, 256]\n",
    "    [None, 50]\n",
    "    L2 regu elems: 3\n",
    "    train_model(50001, 500, 128, graph, is_saving=True, keep_prob = 0.8)\n",
    "    \n",
    "    step 19000, training accuracy 0.953125\n",
    "    Validation accuracy: 0.931158\n",
    "    Minibatch loss at step 19500: 0.336240 with learning rate 0.066342\n",
    "    step 19500, training accuracy 0.960938\n",
    "    Validation accuracy: 0.929022\n",
    "    Minibatch loss at step 20000: 0.383364 with learning rate 0.066342\n",
    "    step 20000, training accuracy 0.953125\n",
    "    Validation accuracy: 0.929022\n",
    "    Minibatch loss at step 20500: 0.252442 with learning rate 0.066342\n",
    "    step 20500, training accuracy 0.992188\n",
    "    Validation accuracy: 0.929342\n",
    "    Minibatch loss at step 21000: 0.328111 with learning rate 0.066342\n",
    "    step 21000, training accuracy 0.96875\n",
    "    Validation accuracy: 0.929128\n",
    "    Minibatch loss at step 21500: 0.289328 with learning rate 0.063025\n",
    "    step 21500, training accuracy 0.992188\n",
    "    Validation accuracy: 0.928701\n",
    "    Minibatch loss at step 22000: 0.368480 with learning rate 0.063025\n",
    "    step 22000, training accuracy 0.960938\n",
    "    Validation accuracy: 0.927366\n",
    "    Minibatch loss at step 22500: 0.335005 with learning rate 0.063025\n",
    "    step 22500, training accuracy 0.976562\n",
    "    Validation accuracy: 0.93057\n",
    "    \n",
    "    test accuracy 0.967956 ./model.ckpt-13000\n",
    "    test accuracy 0.969398 ./model.ckpt-13500\n",
    "    test accuracy 0.970038 ./model.ckpt-14000\n",
    "    test accuracy 0.969237 ./model.ckpt-14500\n",
    "    test accuracy 0.971694 ./model.ckpt-15000\n",
    "    test accuracy 0.97116 ./model.ckpt-15500\n",
    "    test accuracy 0.970946 ./model.ckpt-16000\n",
    "    test accuracy 0.970519 ./model.ckpt-16500\n",
    "    test accuracy 0.970786 ./model.ckpt-17000\n",
    "    test accuracy 0.972121 ./model.ckpt-17500\n",
    "    test accuracy 0.971053 ./model.ckpt-18000\n",
    "    test accuracy 0.970893 ./model.ckpt-18500\n",
    "    test accuracy 0.972495 ./model.ckpt-19000\n",
    "    test accuracy 0.972869 ./model.ckpt-19500\n",
    "    test accuracy 0.972816 ./model.ckpt-20000\n",
    "    test accuracy 0.972228 ./model.ckpt-20500\n",
    "    test accuracy 0.972015 ./model.ckpt-21000\n",
    "    test accuracy 0.972442 ./model.ckpt-21500\n",
    "    test accuracy 0.972655 ./model.ckpt-22000\n",
    "    test accuracy 0.973457 ./model.ckpt-22500\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "default_view": {},
   "name": "4_convolutions.ipynb",
   "provenance": [],
   "version": "0.3.2",
   "views": {}
  },
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}