Tutorials/CNTK_105_Basic_Autoencoder_for_Dimensionality_Reduction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from IPython.display import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNTK 105: Basic autoencoder with MNIST data\n",
    "\n",
    "**Prerequisites**: We assume that you have successfully downloaded the MNIST data by completing the tutorial titled CNTK_103A_MNIST_DataLoader.ipynb.\n",
    "\n",
    "\n",
    "## Introduction\n",
    "\n",
    "In this tutorial we introduce you to the basics of [Autoencoders](https://en.wikipedia.org/wiki/Autoencoder). An autoencoder is an artificial neural network used for unsupervised learning of efficient encodings. In other words, they are used for lossy data-specific compression that is learnt automatically instead of relying on human engineered features. The aim of an autoencoder is to learn a representation (encoding) for a set of data, typically for the purpose of dimensionality reduction. \n",
    "\n",
    "The autoencoders are very specific to the data-set on hand and are different from standard codecs such as JPEG, MPEG standard based encodings. Once the information is encoded and decoded back to original dimensions some amount of information is lost in the process. Given these encodings are specific to data, autoencoders are not used for compression. However, there are two areas where autoencoders have been found very effective in denoising and  dimensionality reduction.\n",
    "\n",
    "Autoencoders have attracted attention since they have long been thought to be a potential approach for unsupervised learning. Truly unsupervised approaches involve learning useful representations without the need for labels. Autoencoders fall under self-supervised learning, a specific instance of supervised learning where the targets are generated from the input data. \n",
    "\n",
    "**Goal** \n",
    "\n",
    "Our goal is to train an autoencoder that compresses MNIST digits image to a vector of smaller dimension and then restores the image. The MNIST data comprises of hand-written digits with little background noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"http://cntk.ai/jup/MNIST-image.jpg\" width=\"300\" height=\"300\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Figure 1\n",
    "Image(url=\"http://cntk.ai/jup/MNIST-image.jpg\", width=300, height=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial, we will use the [MNIST hand-written digits data](https://en.wikipedia.org/wiki/MNIST_database) to illustrate encoding the images and decoding (restoring) them using feed-forward networks. We will visualize the original and the restored images. We illustrate feed forward network based both simple autoencoder and deep autoencoder. More advanced autoencoders will be covered in future 200 series tutorials."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Import the relevant modules\n",
    "from __future__ import print_function\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "import sys\n",
    "\n",
    "# Import CNTK related modules\n",
    "import cntk as C\n",
    "from cntk.device import try_set_default_device, gpu, cpu\n",
    "from cntk.layers import default_options, Dense\n",
    "from cntk.io import StreamConfiguration, StreamDef, StreamDefs, INFINITELY_REPEAT\n",
    "from cntk.io import MinibatchSource, CTFDeserializer\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select the notebook runtime environment devices / settings\n",
    "\n",
    "Set the device to cpu / gpu for the test environment. If you have both CPU and GPU on your machine, you can optionally switch the devices. By default we choose the best available device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Select the right target device when this notebook is being tested:\n",
    "if 'TEST_DEVICE' in os.environ:\n",
    "    import cntk\n",
    "    if os.environ['TEST_DEVICE'] == 'cpu':\n",
    "        C.device.try_set_default_device(C.device.cpu())\n",
    "    else:\n",
    "        C.device.try_set_default_device(C.device.gpu(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two run modes:\n",
    "- *Fast mode*: `isFast` is set to `True`. This is the default mode for the notebooks, which means we train for fewer iterations or train / test on limited data. This ensures functional correctness of the notebook though the models produced are far from what a completed training would produce.\n",
    "\n",
    "- *Slow mode*: We recommend the user to set this flag to `False` once the user has gained familiarity with the notebook content and wants to gain insight from running the notebooks for a longer period with different parameters for training. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "isFast = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data reading\n",
    "\n",
    "In this section, we will read the data generated in CNTK 103 Part A.\n",
    "\n",
    "The data is in the following format:\n",
    "\n",
    "    |labels 0 0 0 0 0 0 0 1 0 0 |features 0 0 0 0 ... \n",
    "                                                  (784 integers each representing a pixel)\n",
    "    \n",
    " In this tutorial we are going to use the image pixels corresponding the integer stream named \"features\". We define a `create_reader` function to read the training and test data using the [CTF deserializer](https://cntk.ai/pythondocs/cntk.io.html?highlight=ctfdeserializer#cntk.io.CTFDeserializer). The labels are [1-hot encoded](https://en.wikipedia.org/wiki/One-hot). We ignore them in this tutorial. \n",
    "\n",
    "We also check if the training and test data file has been downloaded and available for reading by the `create_reader` function. In this tutorial we are using the MNIST data you have downloaded using CNTK_103A_MNIST_DataLoader notebook. The dataset has 60,000 training images and 10,000 test images with each image being 28 x 28 pixels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Read a CTF formatted text (as mentioned above) using the CTF deserializer from a file\n",
    "def create_reader(path, is_training, input_dim, num_label_classes):\n",
    "    return MinibatchSource(CTFDeserializer(path, StreamDefs(\n",
    "        labels_viz = StreamDef(field='labels', shape=num_label_classes, is_sparse=False),\n",
    "        features   = StreamDef(field='features', shape=input_dim, is_sparse=False)\n",
    "    )), randomize = is_training, max_sweeps = INFINITELY_REPEAT if is_training else 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data directory is ..\\Examples\\Image\\DataSets\\MNIST\n"
     ]
    }
   ],
   "source": [
    "# Ensure the training and test data is generated and available for this tutorial.\n",
    "# We search in two locations in the toolkit for the cached MNIST data set.\n",
    "data_found = False\n",
    "for data_dir in [os.path.join(\"..\", \"Examples\", \"Image\", \"DataSets\", \"MNIST\"),\n",
    "                 os.path.join(\"data\", \"MNIST\")]:\n",
    "    train_file = os.path.join(data_dir, \"Train-28x28_cntk_text.txt\")\n",
    "    test_file = os.path.join(data_dir, \"Test-28x28_cntk_text.txt\")\n",
    "    if os.path.isfile(train_file) and os.path.isfile(test_file):\n",
    "        data_found = True\n",
    "        break\n",
    "        \n",
    "if not data_found:\n",
    "    raise ValueError(\"Please generate the data by completing CNTK 103 Part A\")\n",
    "print(\"Data directory is {0}\".format(data_dir))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='#Model Creation'></a>\n",
    "## Model Creation\n",
    "\n",
    "We start with a simple single fully-connected feedforward network as encoder and as decoder (as shown in the figure below):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"http://cntk.ai/jup/SimpleAEfig.jpg\" width=\"200\" height=\"200\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Figure 2\n",
    "Image(url=\"http://cntk.ai/jup/SimpleAEfig.jpg\", width=200, height=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input data are a set of hand written digits images each 28 x28 pixels. In this tutorial, we will consider each image as a linear array of 784 pixel values. These pixels are considered as an input having 784 dimensions, one per pixel. Since the goal of the autoencoder is to compress the data and reconstruct the original image, the output dimension is same as the input dimension. We will compress the input to mere 32 dimensions (referred to as the `encoding_dim`). Additionally, since the maximum input value is 255, we normalize the input between 0 and 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "input_dim = 784\n",
    "encoding_dim = 32\n",
    "output_dim = input_dim\n",
    "\n",
    "def create_model(features):\n",
    "    with default_options(init = C.glorot_uniform()):\n",
    "        # We scale the input pixels to 0-1 range\n",
    "        encode = Dense(encoding_dim, activation = C.relu)(features/255.0)\n",
    "        decode = Dense(input_dim, activation = C.sigmoid)(encode)\n",
    "\n",
    "    return decode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup the network for training and testing\n",
    "\n",
    "In previous tutorials, we have defined each of the training and testing phases separately. In this tutorial, we combine the two componets in one place such that this template could be used as a recipe for your usage.  \n",
    "\n",
    "The `train_and_test` function performs two major tasks:\n",
    "- Train the model\n",
    "- Evaluate the accuracy of the model on test data\n",
    "\n",
    "For training:\n",
    "\n",
    "> The function takes a reader (`reader_train`), a model function (`model_func`) and the target (a.k.a `label`) as input. In this tutorial, we show how to create and pass your **own** loss function. We normalize the `label` function to emit value between 0 and 1 for us to compute the label error using `C.classification_error` function.\n",
    "\n",
    "> We use Adam optimizer in this tutorial from a range of [learners](https://www.cntk.ai/pythondocs/cntk.learner.html#module-cntk.learner) (optimizers) available in the toolkit.  \n",
    "\n",
    "For testing:\n",
    "\n",
    "> The function additionally takes a reader  (`reader_test`) and evaluates the predicted pixel values made by the model against reference data, in this case the original pixel values for each image.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def train_and_test(reader_train, reader_test, model_func):\n",
    "    \n",
    "    ###############################################\n",
    "    # Training the model\n",
    "    ###############################################\n",
    "    \n",
    "    # Instantiate the input and the label variables\n",
    "    input = C.input(input_dim)\n",
    "    label = C.input(input_dim)\n",
    "    \n",
    "    # Create the model function\n",
    "    model = model_func(input)\n",
    "    \n",
    "    # The labels for this network is same as the input MNIST image.\n",
    "    # Note: Inside the model we are scaling the input to 0-1 range\n",
    "    # Hence we rescale the label to the same range\n",
    "    # We show how one can use their custom loss function\n",
    "    # loss = -(y* log(p)+ (1-y) * log(1-p)) where p = model output and y = target\n",
    "    # We have normalized the input between 0-1. Hence we scale the target to same range\n",
    "    \n",
    "    target = label/255.0 \n",
    "    loss = -(target * C.log(model) + (1 - target) * C.log(1 - model))\n",
    "    label_error  = C.classification_error(model, target)\n",
    "    \n",
    "    # training config\n",
    "    epoch_size = 30000        # 30000 samples is half the dataset size \n",
    "    minibatch_size = 64\n",
    "    num_sweeps_to_train_with = 5 if isFast else 100\n",
    "    num_samples_per_sweep = 60000\n",
    "    num_minibatches_to_train = (num_samples_per_sweep * num_sweeps_to_train_with) // minibatch_size\n",
    " \n",
    "    \n",
    "    # Instantiate the trainer object to drive the model training\n",
    "    lr_per_sample = [0.00003]\n",
    "    lr_schedule = C.learning_rate_schedule(lr_per_sample, C.UnitType.sample, epoch_size)\n",
    "    \n",
    "    # Momentum\n",
    "    momentum_as_time_constant = C.momentum_as_time_constant_schedule(700)\n",
    "    \n",
    "    # We use a variant of the Adam optimizer which is known to work well on this dataset\n",
    "    # Feel free to try other optimizers from \n",
    "    # https://www.cntk.ai/pythondocs/cntk.learner.html#module-cntk.learner\n",
    "    learner = C.fsadagrad(model.parameters,\n",
    "                          lr=lr_schedule, momentum=momentum_as_time_constant) \n",
    "    \n",
    "    # Instantiate the trainer\n",
    "    progress_printer = C.logging.ProgressPrinter(0)\n",
    "    trainer = C.Trainer(model, (loss, label_error), learner, progress_printer)\n",
    "    \n",
    "    # Map the data streams to the input and labels.\n",
    "    # Note: for autoencoders input == label\n",
    "    input_map = {\n",
    "        input  : reader_train.streams.features,\n",
    "        label  : reader_train.streams.features\n",
    "    } \n",
    "    \n",
    "    aggregate_metric = 0\n",
    "    for i in range(num_minibatches_to_train):\n",
    "        # Read a mini batch from the training data file\n",
    "        data = reader_train.next_minibatch(minibatch_size, input_map = input_map)\n",
    "        \n",
    "        # Run the trainer on and perform model training\n",
    "        trainer.train_minibatch(data)\n",
    "        samples = trainer.previous_minibatch_sample_count\n",
    "        aggregate_metric += trainer.previous_minibatch_evaluation_average * samples\n",
    "        \n",
    "    train_error = (aggregate_metric*100.0) / (trainer.total_number_of_samples_seen)\n",
    "    print(\"Average training error: {0:0.2f}%\".format(train_error))\n",
    "        \n",
    "    #############################################################################\n",
    "    # Testing the model\n",
    "    # Note: we use a test file reader to read data different from a training data\n",
    "    #############################################################################\n",
    "        \n",
    "    # Test data for trained model\n",
    "    test_minibatch_size = 32\n",
    "    num_samples = 10000\n",
    "    num_minibatches_to_test = num_samples / test_minibatch_size\n",
    "    test_result = 0.0\n",
    "    \n",
    "    # Test error metric calculation\n",
    "    metric_numer    = 0\n",
    "    metric_denom    = 0\n",
    "\n",
    "    test_input_map = {\n",
    "        input  : reader_test.streams.features,\n",
    "        label  : reader_test.streams.features\n",
    "    }\n",
    "\n",
    "    for i in range(0, int(num_minibatches_to_test)):\n",
    "        \n",
    "        # We are loading test data in batches specified by test_minibatch_size\n",
    "        # Each data point in the minibatch is a MNIST digit image of 784 dimensions \n",
    "        # with one pixel per dimension that we will encode / decode with the \n",
    "        # trained model.\n",
    "        data = reader_test.next_minibatch(test_minibatch_size,\n",
    "                                       input_map = test_input_map)\n",
    "\n",
    "        # Specify the mapping of input variables in the model to actual\n",
    "        # minibatch data to be tested with\n",
    "        eval_error = trainer.test_minibatch(data)\n",
    "        \n",
    "        # minibatch data to be trained with\n",
    "        metric_numer += np.abs(eval_error * test_minibatch_size)\n",
    "        metric_denom += test_minibatch_size\n",
    "\n",
    "    # Average of evaluation errors of all test minibatches\n",
    "    test_error = (metric_numer*100.0) / (metric_denom) \n",
    "    print(\"Average test error: {0:0.2f}%\".format(test_error))\n",
    "    \n",
    "    return model, train_error, test_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us train the simple autoencoder. We create a training and a test reader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " average      since    average      since      examples\n",
      "    loss       last     metric       last              \n",
      " ------------------------------------------------------\n",
      "      544        544          0          0            64\n",
      "      544        544          0          0           192\n",
      "      543        543          0          0           448\n",
      "      542        541          0          0           960\n",
      "      537        532          0          0          1984\n",
      "      493        451          0          0          4032\n",
      "      383        275          0          0          8128\n",
      "      303        223          0          0         16320\n",
      "      251        199          0          0         32704\n",
      "      209        168          0          0         65472\n",
      "      174        139          0          0        131008\n",
      "      144        113          0          0        262080\n",
      "Average training error: 11.33%\n",
      "Average test error: 3.12%\n"
     ]
    }
   ],
   "source": [
    "num_label_classes = 10\n",
    "reader_train = create_reader(train_file, True, input_dim, num_label_classes)\n",
    "reader_test = create_reader(test_file, False, input_dim, num_label_classes)\n",
    "model, simple_ae_train_error, simple_ae_test_error = train_and_test(reader_train, \n",
    "                                                                    reader_test, \n",
    "                                                                    model_func = create_model )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize the simple autoencoder results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original image statistics:\n",
      "Max: 255.00, Median: 0.00, Mean: 24.07, Min: 0.00\n",
      "Decoded image statistics:\n",
      "Max: 249.56, Median: 0.58, Mean: 27.02, Min: 0.00\n"
     ]
    }
   ],
   "source": [
    "# Read some data to run the eval\n",
    "num_label_classes = 10\n",
    "reader_eval = create_reader(test_file, False, input_dim, num_label_classes)\n",
    "\n",
    "eval_minibatch_size = 50\n",
    "eval_input_map = { input  : reader_eval.streams.features }    \n",
    "    \n",
    "eval_data = reader_eval.next_minibatch(eval_minibatch_size,\n",
    "                                  input_map = eval_input_map)\n",
    "\n",
    "img_data = eval_data[input].asarray()\n",
    "\n",
    "# Select a random image\n",
    "np.random.seed(0) \n",
    "idx = np.random.choice(eval_minibatch_size)\n",
    "\n",
    "orig_image = img_data[idx,:,:]\n",
    "decoded_image = model.eval(orig_image)[0]*255\n",
    "\n",
    "# Print image statistics\n",
    "def print_image_stats(img, text):\n",
    "    print(text)\n",
    "    print(\"Max: {0:.2f}, Median: {1:.2f}, Mean: {2:.2f}, Min: {3:.2f}\".format(np.max(img),\n",
    "                                                                              np.median(img),\n",
    "                                                                              np.mean(img),\n",
    "                                                                              np.min(img))) \n",
    "    \n",
    "# Print original image\n",
    "print_image_stats(orig_image, \"Original image statistics:\")\n",
    "\n",
    "# Print decoded image\n",
    "print_image_stats(decoded_image, \"Decoded image statistics:\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us plot the original and the decoded image. They should look visually similar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Define a helper function to plot a pair of images\n",
    "def plot_image_pair(img1, text1, img2, text2):\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6, 6))\n",
    "\n",
    "    axes[0].imshow(img1, cmap=\"gray\")\n",
    "    axes[0].set_title(text1)\n",
    "    axes[0].axis(\"off\")\n",
    "\n",
    "    axes[1].imshow(img2, cmap=\"gray\")\n",
    "    axes[1].set_title(text2)\n",
    "    axes[1].axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAADDCAYAAABJYEAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nLBGMtA0Gg2GJ8P8BH4v4dw/GKAsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1deb0bb2400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the original and the decoded image\n",
    "img1 = orig_image.reshape(28,28)\n",
    "text1 = 'Original image'\n",
    "\n",
    "img2 = decoded_image.reshape(28,28)\n",
    "text2 = 'Decoded image'\n",
    "\n",
    "plot_image_pair(img1, text1, img2, text2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Deep Auto encoder\n",
    "\n",
    "We do not have to limit ourselves to a single layer as encoder or decoder, we could instead use a stack of dense layers. Let us create a deep autoencoder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"http://cntk.ai/jup/DeepAEfig.jpg\" width=\"500\" height=\"300\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Figure 3\n",
    "Image(url=\"http://cntk.ai/jup/DeepAEfig.jpg\", width=500, height=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The encoding dimensions are 128, 64 and 32 while the decoding dimensions are symmetrically opposite 64, 128 and 784. This increases the number of parameters used to model the transformation and achieves lower error rates at the cost of longer training duration and memory footprint. If we train this deep encoder for larger number iterations by turning the `isFast` flag to be `False`, we get a lower error and the reconstructed images are also marginally better. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "input_dim = 784\n",
    "encoding_dims = [128,64,32]\n",
    "decoding_dims = [64,128]\n",
    "\n",
    "encoded_model = None\n",
    "\n",
    "def create_deep_model(features):\n",
    "    with default_options(init = C.glorot_uniform()):\n",
    "        encode = C.element_times(C.constant(1.0/255.0), features)\n",
    "\n",
    "        for encoding_dim in encoding_dims:\n",
    "            encode = Dense(encoding_dim, activation = C.relu)(encode)\n",
    "\n",
    "        global encoded_model\n",
    "        encoded_model= encode\n",
    "        \n",
    "        decode = encode\n",
    "        for decoding_dim in decoding_dims:\n",
    "            decode = Dense(decoding_dim, activation = C.relu)(decode)\n",
    "\n",
    "        decode = Dense(input_dim, activation = C.sigmoid)(decode)\n",
    "        return decode  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " average      since    average      since      examples\n",
      "    loss       last     metric       last              \n",
      " ------------------------------------------------------\n",
      "      543        543          0          0            64\n",
      "      543        543          0          0           192\n",
      "      543        543          0          0           448\n",
      "      542        541          0          0           960\n",
      "      528        514          0          0          1984\n",
      "      411        299          0          0          4032\n",
      "      313        217          0          0          8128\n",
      "      259        204          0          0         16320\n",
      "      217        176          0          0         32704\n",
      "      179        141          0          0         65472\n",
      "      148        118          0          0        131008\n",
      "      124         99          0          0        262080\n",
      "Average training error: 10.34%\n",
      "Average test error: 3.42%\n"
     ]
    }
   ],
   "source": [
    "num_label_classes = 10\n",
    "reader_train = create_reader(train_file, True, input_dim, num_label_classes)\n",
    "reader_test = create_reader(test_file, False, input_dim, num_label_classes)\n",
    "\n",
    "model, deep_ae_train_error, deep_ae_test_error = train_and_test(reader_train, \n",
    "                                                                reader_test, \n",
    "                                                                model_func = create_deep_model) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize the deep autoencoder results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original image statistics:\n",
      "Max: 255.00, Median: 0.00, Mean: 24.07, Min: 0.00\n",
      "Decoded image statistics:\n",
      "Max: 251.74, Median: 0.02, Mean: 23.84, Min: 0.00\n"
     ]
    }
   ],
   "source": [
    "# Run the same image as the simple autoencoder through the deep encoder\n",
    "orig_image = img_data[idx,:,:]\n",
    "decoded_image = model.eval(orig_image)[0]*255\n",
    "\n",
    "# Print image statistics\n",
    "def print_image_stats(img, text):\n",
    "    print(text)\n",
    "    print(\"Max: {0:.2f}, Median: {1:.2f}, Mean: {2:.2f}, Min: {3:.2f}\".format(np.max(img),\n",
    "                                                                              np.median(img),\n",
    "                                                                              np.mean(img),\n",
    "                                                                              np.min(img))) \n",
    "    \n",
    "# Print original image\n",
    "print_image_stats(orig_image, \"Original image statistics:\")\n",
    "\n",
    "# Print decoded image\n",
    "print_image_stats(decoded_image, \"Decoded image statistics:\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us plot the original and the decoded image with the deep autoencoder. They should look visually similar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAADDCAYAAABJYEAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1dec96f2470>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the original and the decoded image\n",
    "img1 = orig_image.reshape(28,28)\n",
    "text1 = 'Original image'\n",
    "\n",
    "img2 = decoded_image.reshape(28,28)\n",
    "text2 = 'Decoded image'\n",
    "\n",
    "plot_image_pair(img1, text1, img2, text2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have shown how to encode and decode an input. In this section we will explore how we can compare one to another and also show how to extract an encoded input for a given input. For visualizing high dimension data in 2D, [t-SNE](http://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html) is probably one of the best methods. However, it typically requires relatively low-dimensional data. So a good strategy for visualizing similarity relationships in high-dimensional data is to encode data into a low-dimensional space (e.g. 32 dimensional) using an autoencoder first, extract the encoding of the input data followed by using t-SNE for mapping the compressed data to a 2D plane. \n",
    "\n",
    "We will use the deep autoencoder outputs to:\n",
    "- Compare two images and\n",
    "- Show how we can retrieve an encoded (compressed) data. \n",
    "\n",
    "First we need to read some image data along with their labels. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Read some data to run get the image data and the corresponding labels\n",
    "num_label_classes = 10\n",
    "reader_viz = create_reader(test_file, False, input_dim, num_label_classes)\n",
    "\n",
    "image = C.input(input_dim)\n",
    "image_label = C.input(num_label_classes)\n",
    "\n",
    "viz_minibatch_size = 50\n",
    "\n",
    "viz_input_map = { \n",
    "    image  : reader_viz.streams.features, \n",
    "    image_label  : reader_viz.streams.labels_viz \n",
    "}    \n",
    "    \n",
    "viz_data = reader_eval.next_minibatch(viz_minibatch_size,\n",
    "                                  input_map = viz_input_map)\n",
    "\n",
    "img_data   = viz_data[image].asarray()\n",
    "imglabel_raw = viz_data[image_label].asarray()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: [7, 24, 39, 44, 46]\n",
      "3: [1, 13, 18, 26, 37, 40, 43]\n",
      "9: [8, 12, 23, 28, 42, 49]\n"
     ]
    }
   ],
   "source": [
    "# Map the image labels into indices in minibatch array\n",
    "img_labels = [np.argmax(imglabel_raw[i,:,:]) for i in range(0, imglabel_raw.shape[0])]       \n",
    "        \n",
    "from collections import defaultdict\n",
    "label_dict=defaultdict(list)\n",
    "for img_idx, img_label, in enumerate(img_labels):\n",
    "    label_dict[img_label].append(img_idx)        \n",
    "    \n",
    "# Print indices corresponding to 3 digits\n",
    "randIdx = [1, 3, 9]\n",
    "for i in randIdx:\n",
    "    print(\"{0}: {1}\".format(i, label_dict[i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will [compute cosine distance](https://en.wikipedia.org/wiki/Cosine_similarity) between two images using `scipy`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from scipy import spatial\n",
    "\n",
    "def image_pair_cosine_distance(img1, img2):\n",
    "    if img1.size != img2.size:\n",
    "        raise ValueError(\"Two images need to be of same dimension\")\n",
    "    return 1 - spatial.distance.cosine(img1, img2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance between two original image: 0.294\n",
      "Distance between two decoded image: 0.364\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAADDCAYAAABJYEAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1deb55f7f60>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAADDCAYAAABJYEAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nP4FytTVJOwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1deb55f7fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let s compute the distance between two images of the same number\n",
    "digit_of_interest = 6\n",
    "\n",
    "digit_index_list = label_dict[digit_of_interest]\n",
    "\n",
    "if len(digit_index_list) < 2:\n",
    "    print(\"Need at least two images to compare\")\n",
    "else:\n",
    "    imgA = img_data[digit_index_list[0],:,:][0] \n",
    "    imgB = img_data[digit_index_list[1],:,:][0]\n",
    "    \n",
    "    # Print distance between original image\n",
    "    imgA_B_dist = image_pair_cosine_distance(imgA, imgB)\n",
    "    print(\"Distance between two original image: {0:.3f}\".format(imgA_B_dist))\n",
    "    \n",
    "    # Plot the two images\n",
    "    img1 = imgA.reshape(28,28)\n",
    "    text1 = 'Original image 1'\n",
    "\n",
    "    img2 = imgB.reshape(28,28)\n",
    "    text2 = 'Original image 2'\n",
    "\n",
    "    plot_image_pair(img1, text1, img2, text2)\n",
    "    \n",
    "    # Decode the encoded stream \n",
    "    imgA_decoded =  model.eval([imgA])[0]\n",
    "    imgB_decoded =  model.eval([imgB])   [0]    \n",
    "    imgA_B_decoded_dist = image_pair_cosine_distance(imgA_decoded, imgB_decoded)\n",
    "\n",
    "    # Print distance between original image\n",
    "    print(\"Distance between two decoded image: {0:.3f}\".format(imgA_B_decoded_dist))\n",
    "    \n",
    "    # Plot the two images\n",
    "    # Plot the original and the decoded image\n",
    "    img1 = imgA_decoded.reshape(28,28)\n",
    "    text1 = 'Decoded image 1'\n",
    "\n",
    "    img2 = imgB_decoded.reshape(28,28)\n",
    "    text2 = 'Decoded image 2'\n",
    "\n",
    "    plot_image_pair(img1, text1, img2, text2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: The cosine distance between the original images comparable to the distance between the corresponding decoded images. A value of 1 indicates high similarity between the images and 0 indicates no similarity.\n",
    "\n",
    "Let us now see how to get the encoded vector corresponding to an input image. This should have the dimension of the choke point in the network shown in the figure with the box labeled `E`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the original image is 784 and the encoded image is  32\n",
      "\n",
      "The encoded image: \n",
      "[ 10.67665672   0.           2.66087842   7.24648523  18.65323448\n",
      "   4.45659447  16.96177864   0.           5.24145746  13.33063316\n",
      "   4.96198463   0.           8.77662182   0.          14.81408119   0.\n",
      "  17.86081696  19.46860123   0.          18.38960457   6.43198586\n",
      "   7.17701435   0.          15.3874712    6.56258059  10.01450729\n",
      "   9.17179489  19.95338249   8.373806    10.42320824  22.69996262\n",
      "  10.92036629]\n"
     ]
    }
   ],
   "source": [
    "imgA = img_data[digit_index_list[0],:,:][0] \n",
    "imgA_encoded =  encoded_model.eval([imgA])\n",
    "\n",
    "print(\"Length of the original image is {0:3d} and the encoded image is {1:3d}\".format(len(imgA), \n",
    "                                                                                      len(imgA_encoded[0])))\n",
    "print(\"\\nThe encoded image: \")\n",
    "print(imgA_encoded[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us compare the distance between different digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance between two original image: 0.376\n",
      "Distance between two decoded image: 0.435\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAADDCAYAAABJYEAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJztfVuIbNt61jeru+t+667qtXr1OnufYy4oIooYk6h4IUQk\nUSMYH9SQGOKDGoiKyYNJNIkG9MELSLyQ+CAYjYkR4gWCeBQlSg4IBg1GEcScs8/ea3d3dXXX/V41\nfej+xvrnX2NWV997Vv0fDObs6u6qmlVjfPMf/+X7gzAMYTAYDIZkIPXcb8BgMBgM68NI22AwGBIE\nI22DwWBIEIy0DQaDIUEw0jYYDIYEwUjbYDAYEgQjbQBBEHx/EAQ/8dB/u8ZzLYIg+IqY3/18EATf\n/hCvY9he2NzePASblqcdBMF3AvgLAL4SQBvAvwTw/WEYtp/zffkQBMEcwFeHYfj/nvu93AVBEOwB\n+CkAXwPgswB+TxiGv/C872pzYXP76RAEwdcB+FEAvwXADMB/AvDnwjA8ec73BWyYpR0EwfcC+OsA\nvhdAGcDX44pMPh8EwW7M/+w83TtcfvlnfO2Hwn8G8G0APn3uN7LJsLn95NgH8OO4+ow/C6AH4B89\n6zsiwjDciAGgBKAL4FvV4wUAZwC+8/rnHwbwswB+EkALwHddP/aT4n++A8AXATQA/CUAvwrgG8T/\n/+T1+WcBLK7//kvXr/MD4nl+K4BfBHAJ4BMAPwZgV/x+AeArYq7nPwL4ruvzPwHgvwD429fP9X8B\n/Lbrxz8CcALgO8T/fjOAX8KVNfYlAD+snnvV9QUA/uL1azQA/DSA6hqf/5cB/K7nngebOGxuP+/c\nvv7f3wyg/dxzIQzDjbK0fzuADICfkw+GYdgH8PMAfq94+FsA/PMwDKu42t4DwNW3GgS/HsDfA/DH\nALwBUAFwrF5L+5R+B4CvBvCNAH4oCIJfe/34HMCfB3CAq4n4DQC++26Xh68F8N+vn+uf4WrCfQ2u\ntsrfDuDvBkGQv/7bHoBvD8OwAuD3A/jTQRB8y5rX92dx9fn8zuvHLwH8/Tu+Z8PDwOb288/t3w3g\nV+54fQ+KTSLtOoDzMAwXnt99ev174gthGP4bAAjDcKT+9lsB/OswDL8QhuEMwA/d8LohgB8Jw3AS\nhuEvA/gfAH7T9XP/UhiG/zW8wkcAfgJXX/5d8KthGP7j8Oq2/zMAPgPgr4RhOA3D8PMAJgC+6vp1\nfyEMw1+5Pv+fuFoEfN2bru9PAfjBMAw/DcNwCuCvAvgjQRBs0lxJGmxuP+PcDoLgNwL4ywC+747X\n96Dw+sISinMA9SAIUp7J/eb698SXVzzPsfx9GIbDIAiaN7z2qTgfACgCQBAEX42rbd/XAMjh6vP+\nbzc81zqvMbx+b+fqMb7u1+HK//kbAKSvx89e/91N1/dZAD8XBAE/wwDAFMBrmN/6uWBz+5nmdhAE\nX4Wr3cz3hGH4i3e5uIfGJllPXwAwBvCH5YNBEBQBfBOAfy8eXpUy8ymu7vT8/xyA2h3f0z8A8L8B\nfOX1dvUH8TQBmn+Kq8yCt9ev++PidW+6vo8AfFMYhgfXYz8Mw0IYhkbYzweb2+/xZHM7CILPAvg8\nrqz+n/L9zXNgY0g7DMMOrrY7PxYEwe8LgmA3CILP4Wq79RGAf7LmU/0LAH8wCIKvv05p+5Eb/n7V\nRC0B6IRhOAiC4NcB+DNrvod1sOp1iwAuwzCcBkHwtQD+uPjdTdf34wD+WhAEHwJAEASH9Bl630QQ\npIMgyF7/mAmCIHPbCzGshs3tCJ5kbgdB8BbAfwDwY2EY/sM7XsejYGNIGwDCMPwbAH4AwN/EVXT5\nC7iKMH/jtQ9rnef4XwC+B1cL4h2ADq4i5+O4f1nx8/cB+LYgCDq4mjA/fcP/rvu7m173uwH8aBAE\nbVxF0H/G/dHN1/d3APwrAP/u+v9/EVeBojj8HwB9XG1N/y2AAReF4eFgc9vhqeb2nwTwawD8SBAE\nnSAIutfX+uzYuOKah0YQBAVcpU99VRiGX3ru9/PQ2PTrM8Rj07/7Tb2+jbK0HwpBEPyBIAhy11/6\n3wLwy5v0pW/69Rnisenf/aZfH2CkHYc/hKvt1ce4yhX9o8/7dh4cm359hnhs+ne/6ddn7hGDwWBI\nEszSNhgMhgTh0YtrgiAwU97wqAjD8FnEiWxuGx4bvrltlrbBYDAkCEbaBoPBkCAYaRsMBkOCYKRt\nMBgMCYKRtsFgMCQIRtoGg8GQIBhpGwwGQ4JgpG0wGAwJgpG2wWAwJAhG2gaDwZAgGGkbDAZDgmCk\nbTAYDAmCkbbBYDAkCEbaBoPBkCAYaRsMBkOCYKRtMBgMCYKRtsFgMCQIRtoGg8GQIBhpGwwGQ4Jg\npG0wGAwJgpG2wWAwJAhG2gaDwZAgGGkbDAZDgrD73G/AYDBsDoIgQBAESKVS7jwIgrX/PwxDhGGI\nxWLhjoYojLQNBsODIZVKYWdnxx13dnaWSHsVic/n88ggiRvew0jbYDA8GEjWu7u7bkhr+yarez6f\nYzqdYjabAYCzuA3vYaRtMBgeBCTnnZ0d7O3tYW9vD+l0eslNsoq4p9Op+/1isXDkbXgPI22DwfBg\nkJZ2Op1GJpOJ+LcBrPRzp1JXuREk7Nv4w7cFiSVt+WXqO/iqL1re9fW4a/DkMcGtoTzqQI3cQupj\n3GMGw32g1wvJOpfLIZ/PI5fLuUG/9jqkPRqNMBqNMBwO3XE6nd77/XLdSB+5XEdxQ/7vS0HiSNtH\nsDxPpVJLd3WN3d1dFyDhOX1v+vy5wPfuI+fFYoHpdOrGZDJxPkA5AfW5ReMN94UkXekC2d3dda6Q\nUqmEUqmEYrHojvRr839XGUTj8fhRSFsGNxeLBebzOWazmXfw9/LoI/LnQiJJm+Tsi1THRayJdDrt\nBicat3H6/CVAR9Nns5mbzMPhEIPBAMPhEOPxOELsetLpyWcw3AZ6B7q7u4tMJoNsNutGPp9HtVqN\njEqlgr29vTuT9mg0wmQyuff7p5Ezm80iBs9kMsF4PI4MSeA+g+i511CiSFtvxaTFrAd9YxpykmWz\nWeRyOXeUI5vNPvHVLbt1wjBcmjyz2Qy9Xg+9Xg/dbhedTsddM0ldk/x8PnfPFwSBkbbhVvC5Ekna\nhULBjVKphFqt5ka9XsfBwYELRsrnigNJWxL3Q5C2JGeej0YjZ/QMBgN3TjLn63K9cJf63OsoUaQN\nIGJh041Bq1mOOPdGoVBAPp93x3w+j2KxiEKhEDnm8/mlL0b+/NC/8/nowzB07g95bLfbaLVayGaz\nbuuZSqUixM6hXS0kcIPhtvCRdj6fR7lcRrlcxv7+Pl69eoVXr17h9evX7jyTySz9fxx8pD2dTu9N\nkHJ3yvPBYIBut+sMIPLGaDRybtYwDF2+OHBF3M9t+CSOtLWlTZLW7o040qbPTfrdOOnK5TIqlQrK\n5TJKpdITX9lycHWxWEQsA46Liwvkcjns7l59fdy+SV/3dDp1uw0SNieiwXBb6ID97u4ustmss7D3\n9/dRr9dxdHSE4+NjvHnzxh0zmczaaX9xpA3cz488GAzQ7/cjx2636wwgaehpwp5Op0tWtlnaayKV\nSjnfmbSWM5nM0lhlaXPwOWhdcxQKBeRyuSe+umXSDsMwEuTJZDJuy0Zrhwun2+0uWeTT6TQyUXk+\nHo9fjH/O8DIhydW3vmhZcxwcHODg4ACHh4eoVqsolUpuJ8i1uI6LhDvovb09R5A8v+/1pFIpt5ay\n2azzyefzeZRKJVSrVXS7XWeR68GbCYdeR8DTBCgTRdo7OzvIZrNuwjDYIb8AHmmFakg/tvRr61Sl\np/Zp+0p9wzB0u4npdIpMJoPZbOYey2azKBaLqFQqGAwGEV8crfNOp4NWq4VWq4VUKhUJVsphxG0g\nJKlyzemMkEqlElmDHCTxQqHgcrT5nPK46rU5vwm5lu86T7k7oPEjDb9SqbTk15ZulOFwiF6vh06n\n4+JInU7HuU3kGjLSVqClXS6XUa/Xnc9Mk/Aq0pbZI3LQvSLdLE+JONLe29tbCjBKwuZE452fZM1j\ns9l0i4fulul06p4LeHl5qIbng692gaR9cHCAWq2Gg4MDlxlSrVZRLpfdUe5W0+l0xCW3jmuOpM35\nmEqlvHEYHQy8KY5E652GD3ej0u3INaTdM6PRCO12G+fn5zg/P0cqlXJZXPP5PFLB+RRIHGnncjlU\nKhXU63UcHx/jM5/5DPL5fMRizmazkTu1hM7Pjss+eeo87TjS9lnFuVwukrIUl7o0Ho+Ry+XcxB+P\nx277pwOUBgMhSVvubmu1Go6OjnB0dIT9/X0X/+EolUpLbpTbxlGkZU5Dw1codlvQ+GEwnkMG73mu\n3SCj0QgXFxfuemazGQaDATqdDoIgiAhbPYWvO1GkLScQSftzn/vcUgVWPp+PtbR11WNcoc5TB+zi\nXk9XZcUV3HCySYthPB67VMDRaIRerxe5ofE5LDhpILTfWVraJO0PP/wQBwcHjqg5CoWCq5uQ47av\nLzPEgGWivgsp+tZRXGWxXkej0QiNRgNBEDjCZvCSJM0bzFMgUaTNoEQul3MR68PDw4ilzWOcpb2p\noCWtB/1x3W7XRcun06mbkMxSMWGe7YM2Xny7zkwmg3q9jnq9jsPDQ+eSPDg4iATwGbzXpDibzbxV\nunHE6ysfj0uJ9f1v3M/SIJNHWWLP581ms0u7WACR2ohWq4VOpxNZawAi6YGPhcSRtg4okKgzmYxz\na2yj5SgnoYy8FwoFVCoVHBwcuMKB3d1dl58qXSeG7YEuUEulUi6IL92MhUIBx8fHOD4+xuvXr52F\nTZLmupNCT7qKV8ZkZGzGB9//ynRVeYzT2fERP29CLLvX0hXyyPdGrgEQyTCp1Wro9/uYTCYuK6vX\n6wFAJD3wsZAo0gbe+6SZtsOUP1lUs42kDUQnGX8uFArOH8kA5O7uLi4uLtwENcLePnCuSO0QEhNr\nF3h89eqVs7JrtRoqlYrLDkmn00ukLf3DvtjLZDKJ3dlpTZ3JZOJIW95gpOtklQgUz31pi76EBBo8\nNHpI5LlcDsViEdVq1QX+5/M5Wq0Wdnd3EYYhptMpBoPBo393iSJtbWnTKkin02vpjmw65GTmhKOl\nPZlMXKSbi4yETSvBsD2QpE0Co8uROddy8PH9/X2Uy2UXGyHp0/KVpM0sJi0Atao0XWZycMznc6/r\nRrti4uI9DN4zzY9DZ53RQvbFt+iSrVarLgOLFrwk7Nv68O+CxJE2t/+StBkQeK4g4ksArx94vyAX\niwUKhQLG47EjbO5GJGHLgIphO+BzMzKtjyXor1+/xuHhYSTgyHOm8+mAI10gJGvqe9CNwBG3u5P5\n0hzT6XRJpkJaxD6y1kJpMsecR/ri6dKQRqHWNprP5yiVShiNRs5Pz2smYfMzeWwkirSBZZH1bDbr\nTc97KgJ66Ne56w1HWgcS3KZKvQjqK3S7XeTz+a0L2hrg3bHS0n716hXevn2Lt2/f4ujoyJud5SMn\nKR0sBZkYBJdjOBx63xf9w3JMJhOvK0MStiRtn1+cueQsRKO1T5eh/Ex4zjXD1yoWi87CpgFJv3a7\n3Y4IYz0mEkXai8XCkc3FxQVOTk6wv7/v7nBP4SKhHoHO+ZR39bsIM8lAokx58lkY62g4GAyrIKtq\nWRXIfGtaoCRrxoyk79pHltPpFJ1OB+1221UNtttt9Ho9R8a0tEejkfd9SclhaWlPJpNYS1v7sPU6\npNtjsVi4HQDfD90dtJ6DIHCuElnoE+ea1X59I20FVvRJ0i4Wi96gwmMVx2g9Xi3SJAMwt4kiS18d\nF0g6nV7yw/kaPRhxG24DklE6nXYBNoql0XUgSVuuKUnaOitkPB6j3W6j2Wyi2Wzi4uICzWbTad5I\nGdQ49whJVfq1b+PTjitIky6bfr+PfD6PXq/nBKkkSctzvg4QTYKQmWsk7acqyEscadPSbjabrlRW\na4Y8Zp42c5x94jF63MbalqJQPGazWVQqFVQqFcznc5eWBSCyPTXSNtwWJG1a2rKyUZO21qlnFSAr\nCmnADIdDtFotnJ+f4+zsDKenpzg9PXWWtVwrcYFIkqs0ikjauuFJXMGMzwKXhM011uv1Iu4OEjI/\nH7oT4yztyWSytAsxS1tBu0foQ5JBBZ4/lnaIzM2UARbdSWYwGNyKtGn1yCKhYrHoLI1UKoV0Oo1C\noeAmhpSQNOI23AbS0maGES1tVjeStHWHKOB9gw76r8fjsfPtNptNnJyc4JNPPsG7d++cX3qdlD9f\nbrckTV+eNt8Pjz4y90lV9Ho9F6Df2dlx1jPVADOZjHOv+JIgKOJm7pEVkO4RkvJ0OnUaCDK1jRbp\nQ4M3DVZG8VwGTugvu02VIXPOpWRsuVzGbDZzFnaxWHRWB+BvoGAwrAOtFCn1Q2j4kLSB5QYG9BeT\ntIfD4RJpf/zxx/joo4/cWpAaH6sMGp/VrF2Bcs6vqq4kfLIVvV4vYmFz3ZGwc7lcJFNEWtq8qdA9\nIl1Hj43EkfZkMsFgMHABOepq6I4UjyWtKklbDlkZdRfSpm9RbglTqVQkr1UK0wC3y1yJ2zZamt92\nQpetS9ecLLiJ0/CRKaNcA5eXlzg7O0Oj0XA+7cvLS7fr1FWOT329uqJSvg9fup8vdiSTBOTfPWW6\ncaJIm1uy8XjsEtmZ2M70ok6n86juEb627IAhNXg5SLLrQqqQkUgfYgLo4IxeOEbchrtACicx8Nho\nNHBycoJGo4F2u+0yP2Q2x3PNNxKyLF+XGTN0D1WrVRSLxUiJ/kvbySaWtKmqRcLu9/vodrvOJxxn\nIdwXMgdVq4Hp5qG3sSaYdRInOHOfibOKsK0BguEukKR9dnaGd+/e4eTkxBF4q9VaIu3nNBCkP5q7\nCt1mkEN2xDLSvidI2qPRKJLE3+/33baOx8dKv5ERc1+anzzeZoKSsH2dZO4zadaxtA2G22I2m6Hf\n76PVauH09BQff/wxPv7440h3l8FgEDFEntMlJ4OLzDSjpS2tbNkJi5khL61aOHGkzZxKaXHrVKC7\n6PiuC5n76SuquWsLr3Q67Rr0SveIj7BvS+JcKJqwn9v6MSQXtLTpx/7yl7+ML33pS0upsDLo+Jxz\nTTYjloF+n3uE/nz69I207wFJPEmHjoJry/qhghy6tFfuDMzaNhA+Ql01L2azGYbDITqdTiRbxCfF\n+hLgy0uXLhH+XC6XlzRVZIODuJRC4inWUqJIO4nQQvNMMdLavuVyOaKqxl58FJynspom8ptAdxJz\n2xuNBk5PT3FxcYFOp4PhcPhiFpbh6SArGrWrb52bOd0NsgyeKbey/d1TNAXQ0OJxUldeqhhScnZ/\nf99VVmsjSRpVWgyLmV00gqxzzQZAphlxIrBlmhyZTMaJq8tBKcxqtYpSqeQaFmtB+FXkLUmbW9mz\nszNcXFw44R5WhRm2B3IHRiJi0cs6KXmStPP5vLNUmT0FvI//POXc0ml5PPI91mo1133n8PAQh4eH\nLmNEKhf6SJtxNEnaTDrQrs3HhJH2I0NPILZLY/VmoVBAoVDAwcGBa+vEsb+/H6nylJa2nlRx4Da2\n1+uh1Wqh0Wig0Wig1Wo50jZLe/vgI+3buM1kYI/NEyqViksAmM/nmEwmz5J5IZVAeSRp08I+Pj52\nhC2bOsStrThLW5L2U7ltjbQfEdLSpo9a9riUPrVarebu/NICkFoklFVlkHVd0taWNvUgWH4/nU6f\n4uMwvCDEuUdYtbgOaTOwJ90jwHsLO07J77GhC4fYlYek/fr1a7x9+xb1et0ZTSRtWW0sj6vcI2Zp\nbxhkUJETSHbBoCuERM2t26tXr1CpVJb0Fm4bkPT5tM/OziLCVmZpbx9kBpRsCXZbn7a2tCVhP0cX\nKZ+RxBJ16R45Pj5GvV6P5G2vamKg3SMs3WcXGyPtZ4IuWdWlr6sIUxKzLHHVjUQzmYy3nRPJm+2c\nqP3wGNcntbr5OCPkWtrSsJmQhWlsVEDylfIMhUIhkkUh/cSZTMZlYhwcHGAymTiLlKTGVnb3zdOO\nW5fy/cgbiYwXZbNZ15iYbsdKpYJisbhUJRkEwZJOeBiGGAwGrmS/3W472dlWq4Ver/eksSEj7Wto\na9bnF4uzHCicrgeLfOSkSKfTS2lGuhpLbtPuCykMxEXZ7/djNcFlcdBTRsQNTwdZpNbv950cBI0K\nPYdl01uprU3SrlarjrB8pE0ijCseWweapKl6qS1lznPdC/LNmzd48+YNDg8PUalUIutTxomA9y3T\n5Oh0Ori8vESz2cT5+TkajQbOz8/RbDZdyf5tq6DvCiNtvL97+7rGrFNpmUqllnrQsY+e7jW3t7fn\nfGgyECnPGRB5CPhSs2gVSMKWJfiy359hM8HitH6/70icapKStCnfysH5RNIuFouRri9SG6jX67ku\nMJRA1aJn6yDOiJLNeqU6JgP3ck3KHS3TZ5mJpVNoZfEehyRtps2enZ3h8vIS7XYb/X7f7TQeG0ba\n15BkzYkht1c8+kh7Z2cH+/v7kY7VBwcHzmKWWzgGb3yDwcbHtrQZ8dbW9nA4XIr+GzYTJCVpdcsd\no+zKUiqVIo2huQ5oCIRh6OY2VTh7vR7a7Tay2azzcwO4s5SwFHyiyzGfz7sdqx66YEYSOXOyWe2o\nY0XSdcQUxna7vUTap6enzo1klvYTQ/vIpP9Z3s3jhKh2dnZc3ic7Wb969cpZJr60P1kmK/3e8qbx\nEND5tKVSaakzCAe3yYyQP5U+sOHpQReGDBoCWCLtTCbjmgAwiE6SZlcXGiLpdNr5x1utFvL5vGsW\nACBicd8GMvea64UNQcrlcqRghsYT6xt41C4e7ha0r5yfDXWNqObZ6XScoiGD+ScnJ0tZJGZpPxJ0\nOo9soCu/WO22oEC6BkmbfrPj42O8efNmibTl5NPjsaLssny3WCyiUqlEouCatIFoypbUjZBHwopy\nkgmfHEQqlYoYKCRiABEf9nw+d+QpyTydTjtyo4XLv6d+B10PPsTFi2TrL+m+IWGzruHw8NAVpenh\ngy5Hp6+drdOoHErXyMXFhQtAst5BC8WZpf0I0IFBCsDrVl+0sKWvrFAoxFranDiVSgX5fD4iNuML\ncq5bHHNf0PdXLpfd9i2fz3uVCVutlms1xc+BAvZaIVBPdKnNII+G5EA2Nmi1Wi62QpeG7I9IC5zz\ngIFBlovX63VXuMXqWyoAMtDnk3jwrZO9vb0l90axWES1WvVa1+Vy2UmryvZoevham81mM7RaLbTb\nbbRaLXd+fn6O09NTNJvNiPwDg/VPqeGzlaQti1VkmyHZa5JkrYePtFOplKusImmzb9xNE/OxIUmb\n21r6KGV0fD6fO8LmopTNT+P0KfRRKqIZcScLbOfHtmG6M7nsKcnHJcGyiKVarTpSC4IAuVwOzWbT\ndYthfnPczlN3hclms042VQ7pz6bMquxvSb818D7PWg6Zny71Uthxh9a1tLJ5A5IKhk+tmLm1pC19\n1XQb6OAF/0ZGz+NIW1rktLTpM4vL/34K0uZCkr5Huj30oIUtm5Vms9lIowcepWUitcPNfZJcSEub\nBDudTiO7UWYgSeEz7lrpXqlUKphOpwiCwBlIfD4WesmiM0nUvga8+XwetVot4gap1+uRrvE0tLhD\nlL0bgWW1S14r89Rl1yk2cmB6H/OxZf46b0p3lWK+D7aOtOkbY1COlVwykMEj3STSZeILEHJy6iHL\nzeUx7rHHul6+b/q1Odm0DjitE7p2uOVl383BYOAWGS1uWeYLYMlNYkgOSGQstCKpSUlTVvLSxy1T\nZXd2dlAoFJzPmrvYnZ2dCGHv7e0tEbVMiZWxpb29PZRKJdRqNRwdHbnBmJHO7qKxwTnsI20aGjI1\nUQ76q+UgUWt1v+do7rB1pC0tbVrYBwcHEc0P3tF9aXlxWR3aV60J+7nAictIv670kkcSttQ32d3d\nRa/Xi+wc6MPUugySuKWbxJAMkLRlA+1+vx9pGlCtVl2nKGZzAO+D+azilXofwFVDbGpvS9LWaXyy\nUIZHXX7+wQcf4IMPPnDuD/kcdLEAWJqjkrTpGmG2S6fTQbvdRrvddjnY8tjr9bwuRT73U2LrSJuW\nAe/mspMFk/HpKpF+74fOn34qcALL9+0LyiwWCxSLxaXO70zjYpd5Dt2hhM2Mde636ZokB7z5Au8L\nTBaLRSTdjbux8Xjs/MmLxSJCltzN0oWyv7+PWq2GTqfjSr51dxgfafO8VCrh9evXLjuEUsWS/HkE\n4O0oRbceh2wErod0icj3fN+qzofCVpK2zPnUWzJOFJa5SlfBpoKfiRTW4UIsFAoRfx8Jmp3o9VG6\nUpjzbUgO5E2cFY4sLuFOcz6fo9froVaruUYHXFMkNa6vIAhQKpWwv7/vekYycC8JW5K2L/WWvuxK\npeJiS77dHncJenBOytHv950xIt0jzBiRvuu7VHI+FraWtKWgkyZsWf0ogyzP7ep4SPiuhfm2XITc\nmjKqLo8yKCMHsw6Y72pIFmT6JnA1TwaDQSSbhFYqCVvGdPgcTNXb3d11ZeScV5lMBvV6fcnK1pY3\nRzabjejzMItLEjbJlDcZaTwMh0M3Pyn61O12nTSxDETKXWWv18NoNIoo+L0E4t5K0vbp7WorW2pX\nbyJpA8vELQNHLKTQOssctEY4Wq0WLi8vI4Td7/ef6coMd4EvmEyFO5n9wTxlWtTpdNplcviU90ql\nkrOw+beDwSDWRaKHzPbSWVySTGX5ea/Xc3nhNCZ0/nW/34+4TKTrRJ5r2dXnJu6tJG2f3q60sknc\nT52e9xyQWSz0EZKwfSlN9OvpHFamOZKwB4OBt3rU8LJBMqIFvVgsXIHVeDxGt9t1Pm1ZUMO8aVZJ\nSsLl+qHAFGVcfVa2zNHWmSV6aMImadOypl6Irmbkea/Xi+2RqcdLyoraWtKOyw2V7pJ1oe/A8k7s\ny1v2jbj3ehcJS5+ewqpzHvlZ6OfzXa+0ehg4CoLALRoWaOzu7no/H8PLhZ67rKSdTqcRC7larTqx\nJOqYMBhIn7ZUuiRpM88/TntHa/Xw5qFLzX0SqnTlUNyJRC1zrnne7/djyfklY+tIexXuY03ryaOD\nF9oakEOLcHcFAAAYbklEQVQKzcS9h5uIThYrxFkrNz2uqzVXfR4y3535qlSL4/ZSZpTwM+G5EXdy\nwDRZuRuVjTp0qqieP5xT0jrWVrScg0A0sMjgIuMpPPfp5wwGA28ZOo+yYYHs0JOk+bj1pB0nUnNb\nSP1dXTUoWzvN5/OlwAf9g/cBy4hlUYIWrveJ2WvVM2pNyAXk+3xYLcnsEAaptG+QPkYOAJGcbsPL\nhi5h5w6LpM2dlq+hgJw/UqOelrOuhpQZWjIgOp1OI5keMu2Uc022AJMBR2aEyHOStnb9JWVObjVp\n+yoU7wJaBdRtYDqR3MKRsJl5wZxQBkpkalycS2IVWPEoq8OkAJY+lz9zcSwWC+ceifPl02VDS5sE\nn06nEYbhUv72ZDJBr9dzz8vPIAnbUMMVZDCQ+jzS0pZdYKSGCEHi57kUodK6I1ojhK4QpuIx4N1q\ntTAYDCJ1AlL/WmeFyL+RuiHS5ZIUbDVp+3BX8pZlsSRkRp6le2A0GkUCIzy/bz4zNRrkkJKyWqOB\ngUYWUzDrg5+BXnQS0tImeRcKBQRBsBR9Z8ApCAJH2Jsa1N1E+MSipOyqtLR1eqx2jwDvLW6Sth4y\n4MfdKfVQLi8vnZZ1o9FwBpIcNBSkG4Xd0rWypdzxmaW9hdCkfXl5GfHpyu4wZ2dnkdFoNO6d00yN\nBtnujBaRVEArl8vOH8gFwm0rEM2u4c8+MHAkffapVCri05YuEdneykg7WdDSD6yEvI1PW1rYGnI+\nyLRD2Yyg3+/j8vISZ2dnePfuHT755BOXay3dJnFiaOskCSQFW0faUuCfIufMfqA1QIt4XSwWC7dl\nY4pRq9VyvjM5RqORi2ozMNLv9+9taVO8SVoofE1Ztqurv0jwpVLJZYPQb8k0vjiVQv4MwLlMdL67\nVg1c5Ss3PA7iGm9olT155GCWSKVSicii1mo11Gq1SDNq3sg1cd/GDSlzrXnzl6l7cpfa6/WWLG26\n3vTYJGwladMiZjoSt2XsWNHtdnFxcbH2c1KfgYUmPKd7RI7JZBIpkX2oFkX0q3PC85rokpA3qXa7\n7SxxOWR/PVavAYgsQl+RkXSryNRBGeTUZceGp4GUa9DFZHFBajlYDKN3caxOrFarKBaLzlWmg5G3\nhVyftJ6ZvkdjiGuMqYbcOWrVyiS5PG6DrSNt6caQAjMy8nx5eYlSqbT2cy4Wi6US2W636wKRcjAS\nzhJapsvdF0y5o5tF/sy8aaZr0TepO8HXajW3vWRpshakvyl3XKq36cyUTa0sfcmQPmkpfqZ3VTLn\nXitbyt/z7/X8YTBSWul3+Z6lwiCNH9mAgN3PGTOS7kdfmu0mYutIm5anFDQiiXe7XResy+Vyaz9n\nGIaRVCRaCTqtSIqvSwvhIS1tbg95XaPRaEn+kvnVujuP7DZCC4tZIXR/rBLOkv5w6SqRQSoj7KcF\ng8ZUtCT56tgHj7rFHrsw+axyZipxxLXXuw3k+mRs6Pz83BE2M0g6nU6EqGV6bRKDi7fBVpL2eDxe\nImxdxn6bikiK6Mh0o+FwuJS8L9OZdJDkvpDFCNR50ClV/Jlax9p64v+xcm00GiGbzbrXoDj+Knla\n7R7RTRU2WS3xJUKTNjs1xbXvIpEzcF0sFpd83Tq/Oi4/+77uEbopWcWo3SNSE0S7QzaRrImtJG1a\nwNJ94NM2WBdhGHqFZ3RK0WODARfdZVtjZ2cH/X5/KW+bKn9c2OVyOaJxzDStuM+GvyNZyxsCydvc\nI3eHLxh802C3ImlNU/9DNsQ9ODjwttwrFosAliUI9M80RPg7edSVtr7iGxnQ1oF0mb4n87KTll/9\nUNg60uakYN4wH5OWMLdbt3lOWa79krR3feB18qbFBdPr9XBxcYFcLueyRvr9fmTBA3C/I3ju0+QG\n4La6uVwukqVjuBk+ImaKphZc8h3ZJkzn6TPorFNCZbEMvydfCp3uYi61O+RukgVbupkI55DOaOF7\nLhaL2N/fd8QsM76oaROXyrfp2DrSBpY1g6XbQm7/bvN8MkNEWwAvcTKRtEm4DKZeXl66BTWbzdDv\n950qG/BevlWSCC1wBrzy+Xzks6RvUt4MDOtDkxt3RL52eL5Aog426gIsGcfh8zJ4LLOSfJ2J9GNS\nd4fndLfJoDf7lso+jpwvJG2ZwSQJm+8PwJJ7ZBuwdaQtLWr+zO0aJ4muCFznOXWLo5fsW+P7lXnd\ns9nMNV3lZ8Ft6HQ6BQAnw6mvSVvauVwOQRC4tLGLiwunU2GkfTvI4K5Uy2MwURKhzOagi4skLMlc\nasbrIeMQ0tJmvr90Uchz/izJnOeUbq1Wq24HS6taulAoiUCS53zijq/dbkfSC+WOWRoQm46tJG3Z\neFZ/6XGaGzdBa06/5O2aJGreaFKpFLrdrrOwKSTPIqO9vT0UCgW3ZfWVustFRvLO5XJoNBqueEeS\ngeFmSCtbZuXk8/lIvrTPH10ul132h+y7KAudZAxHK0CyglGStq9tlxy+JgLlchmvXr1yN38tfywr\ncOkeka623d1dtNttNJtNFAoFR9ravbkt2DrSBm7+ku9iCSZt0shKMXm9krBbrZZLGczn86hWqxiN\nRs71waO2tNkMAbiq1Nzf34+Qtlna60MXLEnSLpfLLohYq9VwcHDgBh8vFApLHWJkqy6+hj7XgUFJ\n2j7lPJ7rDKrhcIj9/X1nYcvMJSCa109LO5vNulTTxWKBvb09NJtNnJ2doVgsuvRCSdrSENt0bCVp\n3wR+8b7SX61Ctgm+NJkBoNMSV+0afJWR+rOR2se07A3LkO4kGUzUudGyU8z+/n7kqFP36Dv26VbL\ntFOdgioDjLIYTPZOlHUJsj5B+7vl961vPlqrhH8DIFKN66vSTKfTXnGpbYCR9gpwwshoPIOOUjFs\nUyaLTM3S2hTraEnIrTQ/G2qeaDlMQxSpVMoFDWXRk/Y982905gfT82SRDN0gOj+e2Rg6qBjXK1Gr\n6bGaV8uesv5B3uT1zUefS3kDn5Uv56R0D2UymYi0Kl2c2wAj7RVgapVcNBT61+lQmwK9SFYpt2nI\n0nkufC5ylhwbaftBtwB90rSaZdYHKxp9sru0qmXVo1Tek4E6XTFL4pV6H3Jod4fU/JDf9Ww2W7Kk\ndQs/n1/dVykrf9bSCHwu1lvIBIJtgJH2CtDSloUi9OMC7xXJNgWasHUF3E3ELXO/SQbsIUhL21qN\n+cFK1FKphFqthlevXuHw8HBJaoD+YF9TC92JiKTts2BlNTDdHRQTk4MaH3rQSpe7zsVisaRZIonW\nZ2XLuaUh37dP04Y7N1bybguMtFdAWtpMoaJVTcLetMlyF0tbk4EUqaJ8plnaq0H3CEn76OgIb9++\n9ab10YqOaxenpQt0+qm0tEnazKWXZeMsHdcWNa1qGfegf7lUKkUCilxDPt+8NAhW7eA4H7VKId06\n2yZEZqR9De2vlT5GLVlK9TvtJ0yShq8vxVH6TAuFgtOhoG9VStnK5yH0tpvWm7lHbkYQBBExr1Kp\nhGq1GvFVS91zX2PcOJeVDCbLADFdIiRtNsDV2tW+RtS6OA1AhKCpBEi/u+xyI33tsqxdPpe+Bh51\nSfy2ELWEkTainczlQqhWq5E0qoODg4h2NtuKUXFMWiQkqJcIGcWX100/qsxKODw8xNHREQ4ODly6\nVVwuu7S0JRnQL8qKOSNtP6SEgsy64Y1OzlNf5oUPMlAnn5/uK9kYg9kfzLOnOzCuE4wkTlrNsjye\nhF2r1VCv11GtVlEoFCIaNOvcaLT+CI0CWtq6oG3TYaSNqNCR3HKyQ8fh4aHzMYZhiHa7jXK57Px+\nxWIxErgBEElve2mTidero/nVahX1eh31eh2Hh4funDnApVIJmUzG7TD0opOW9nA4RK/Xc915SNpm\nafvhE0qKI23dHWbd52VZObN6SNrMs6Y0L/C+mIql7DorRN9AaGX75F4ZWK1UKkvdkLQB4Nux+oSj\npLTxtqWSGmnjfXRat8kiab9+/Rpv3rzBmzdvAMBp+nJSFgoFtFotp4fAXpCy6vIlERUXnNaw2N/f\nR71ex9HREY6OjvD69WvUarVIShkrHvk88igDXCRts7TXB1Mm17G0b6NZrS14GSjWlrbUU6fLTLsj\nuF58OeVxpfVStEpWxcbl+ssc8nUs7W0yBoy04dccZgFDvV7H69evcXx8jA8++AAAIlrDciKyBHw4\nHEYm5Usjbn29vIZqtercIW/fvsXbt2+xv78fyVbgIubzSMQFuMynfTO0RazdbLLgS1Y0xrmqfM+r\ne4YyWEzSHo/H7jlJwpwr2nXIAL3uiONrrkEtE5k5EjeHfGqbcVa2FKgy98iWQVqeUii+Uqm49CuS\ndhAELrDCyclGASTsTqfjAkMvcSLxeuVNqlQqYX9/3+0sjo+P8eGHH6JarS5tg1cRhMwe0eXNZmmv\nhk9HWvpspaWtQcPA97i24KWlLbN8ptOptwjGVxTjUxiUeeQyv/ym7JC4z0GStk9XW7bzM9LeQsRV\nA/pEdaiwRj9aKpWKbGFpDY1Go0jke9Wk0mXxcT8zAOQrTV4X9D3qhq1HR0eo1+uoVCou6Ch1j+V1\naHGsxWKx1O292+26BqxykRmWQTcAO7YwJc6XgjmZTJa+e18+ts+dwe+rUCi41D2m6M3nc2/JuM61\n5uO605Os3pTFM760WL0uOJjRIsfFxQU+/fRTnJ+fo91uu65QMt1wWwgbMNKOQKcT+bRHaGX4JCZ5\nzgksy3qB1cRN14IeUgeCR74HWdp8m0479D3KUSgUXPCxUqlExJ2kdaQVAqUIvtxqywbH5h65GUzD\nGwwGaLfbAKIdiKQbZDKZRMiR5zqPXhsRMohIo0Oq6bFhgW9o40UTuC6ekTrZcfAZJ7x+ph+2222c\nn5/j448/RqPRcKTN+ffSFTUfA0ba19CRbB9xc+Ky9ZasmNSEnc/nMZlM1iZtuXWVWsQ+4XndDbtQ\nKCCTyax9rcwM0EEjKThESUwd6NI+Url9lVa2JG4LRN6MMAwdaQPv1RblZ8W5OZvNIr5jzkO5I5J/\nzwwQ4H3QndZ1JpNBoVBwNQjaFSYDn/L8JkL3zR3fNet0xOFwiHa7jUaj4cbZ2Zk7b7fbGAwGkeCj\nLh7adBhpY7m6bxVxk7S5UEigOrBXKpVcp/V1Jhb9jFpc3ifiw/6NMpXqNt3jKY+po/qSwHWUX29j\nfQEiaWlL0qa2hQlGxYOWNhCVxwWWXXeLxcK1c2PQkBrUWi5XWtr8Pc9pYfM75P/KdMJV53HNfn2V\njj5IS5s7S5L2+fk53r17h08++QSnp6cRy1ta2ttmZQNG2hHcRNjSl0xpSFoIugqsWq3eirTjBOal\nitpwOMTe3h7K5bLTUOZg/8Z1QH1saa0xM0RuuUna+v1zkclMBFZAasLudruRaL+Rth8kbRK29AVr\n0mZgkZkd2WzWuVLk9+X7P+DqO6RKnnZPaH84z/VR/96Xc32XHHK6RxqNBj755BN88YtfxMnJiUtP\n5PGl92F9TBhpC8g7v5zQWl+Bi4XnnDzaRSJdATdNMF8ARqqqSZW1SqXiSJvFL7clba0IF6e7DESj\n+VxgUqaTx/PzczSbTbRaLXQ6nUiVnW56bFiGTzGS3xP9xiRf3ZOUFrROzfMVQklyZfrgOlkd68A3\nz6XhIgPXvJHL3Zp0i9A1cn5+HnEZUt1vW2GkjWU/rc4HlYNRfTkARPzdnFCSoG6ytGnl0lrX7hF5\nTh8kXSP0Qa8L+jIZxPTJZOqCGe1vZ/m+LOdnd5FGo4FWq+UIWwZVjbBvBxZqsX8nH2MefLvdxuXl\nJSqVylJLMamRo3eQ2metu9k8JKQlzcG0UL2TPDk5wbt373B2doZWq+ViIdtYRBMHI21Et/xaD1oT\nZyaTWZroXAxMqQLg/IfrBkkYYIwLRMrHZCCSPmjmiq8DvlcZ9Zel0dIX6dNeHg6HuLi48A4KDrVa\nLfT7/a3NpX0o0M8r+3fyZ0ooSCEpWeEqe3JqBUCd8fGYvTvjGizobji9Xg/NZhPn5+fuxi/nkNxV\nbDOMtHE7S3symURcIzIQwwg+z+O2ij7o1L641L/ZbBYpt2fqH62wdSAzYeRWWpcr0/UjRaAYbGw2\nm277ysFFpttPaReTEff6oI9bEjYtbB2X8JWNSyNDDl+H9tvk+kvEFfUQjNfQ1cchd2k8l0dmijBI\nynm07fPHSPsakrRJYnHuCZn/ygnECU/Clk1H14HOWV01fAU/t1lwOkAl3Tzav+kTgep0Ori4uMDp\n6SnevXvnRqfTWdod6GDsti+424JEzaMsbNHEK1uP8Zw5/Do1T5aZ04K9LWmv404Jw3CpOpYBai0B\ne3l56QqxZAxHps7aHDLSBhB1j7DiLJVKLRE2j8D7UnDpDrnv9vKxfIr3meRhGC514m63285//e7d\nO3z00Uf46KOPXIqa4eHA3dVoNHKP0b2lBZukrG6lUnG6Mfrv9vb2UCwWlwSpbrNb05AxEA3OGTla\nrRbOz8/doFuErhAZ/N52ktYw0sZy6hGt0F6vh4uLC5dZsVgsXE60bvmk81W1XnBcKpVOM9TjvhNW\nWygyiq9Tvnyg/7rZbEaOjUYDl5eXTmho2/2MTwn5/ckbPXPlZVqgtLSlta1bmLGY6jHAm720tjud\njssyYs9JGfcwN1o8jLSvId0jnCzdbhfNZtPpMjDdLm7Ca4tG+4fjfvb5mHU58l3hKxWWQjzSb+57\nncFgELGIGo2GOzfSfj5I4iZGo1EkJXA8Hi/5tGWBmPRnszXYY0DWIEi/Ngm83+9HWphta9HMujDS\nxvIC4ITp9XrOBTIajdDtdiOSrFK3Q+tAcLHoKjK6VXyaJgxe3peofdemldOk9CeH7zXjgo7c5nLB\nGWk/Lfi98jwMQ1f2Pp/PXUodjQc9dH9JprI+BnzZI4yRcNDS3tbS9NvASBvLC4AE1+12MZ/PMRqN\nXB6y7ten062kNCXT6DRJ+/Qc0um0I2xa3cR9SJwLQBM2gz3y6AN3G41GA6enpzg5OcHJyUkkC8BI\n+2nhm6+0Tvn96l2b3uXpVnOrJHfvC19GlNbT4a7Pgo03w0j7GtKXBlwRpSRsuj1Y2ELtD55rAaZi\nsRjpkO0rZpBH6kjQ6n5oS1sLyssKTKbn+V5Tk/ann36KTz/9dEnIykj7aSHnKgCXEugrpJF/w2Nc\n6fljvVddEelz28kbkSEeRtoC+g7PjBLp3qDwkRaTLxQK6Pf77tjr9dyWcxVhS41uWukcsrUXsCxs\nter981wr8XGrKgsbZG9LjW636/zYLJ7pdDqRsnYLGj0P5GfOc9Mr33wYad8ASYS0WBlYkUEfVnjJ\nrh1yC6rJW1vaWgdEtvby+cV92SiSRKU7RAYdZfqe1A2hJKjGYDBAs9nE5eUlut0uRqPRElnbdtZg\neDoYaa8BkhK3oMzjBhDpiegLRPokKzVxUwtEphDKKjU9NHnz5iGzQXRmiPyZ1Y06ou8D3UMUgCJp\nW5TfYHgeGGmvgHQ10Jol6TG4xyi47ughWy1p3WGfuLyvwk22epK5tnH53L6MEF8ZvBTrkcNHvlT0\nI7HLFlVmZRsMTw8j7Rvg8xuSuGhx+7JDfMQaJxTP7BFppXP42jn5xOeZ8qUbKUjSlsFInTkSlz2i\nm6vyueTnYaRtMDwdgsdecEEQbO2Kjqty9FnfUlOCspoy91sefb7yMAy9GtySsDmm06m3Q05SEYbh\n46U+rMA2z23D08A3t83SfmTI9Cbf73QJua5YTKfTGI/HEYvb53ahpa2JWAcnmREjNYrNUjYYkgMj\n7UeErm7UFWzsySfzVCVh7+7uYjweL/m1te619Glr/W2t56Cb8vL3BoMhGTDSfmRoK5ZFNCR0/iwJ\nlbnhvswR2VlGp//pjBHZ/FRmemh3iVnaBkNyYKT9yPBloPjU/1KplCNraUH7zuMaqPr6WvqyPHwa\n3QaDIRkw0n4C6CwLXzWjT8JV/21cl2vpgvGJ7WhL+qbfGwyGlwsj7WeAjySNOA0Gwzp4HC1Gg8Fg\nMDwKjLQNBoMhQTDSNhgMhgTBSNtgMBgSBCNtg8FgSBCMtA0GgyFBMNI2GAyGBMFI22AwGBIEI22D\nwWBIEIy0DQaDIUEw0jYYDIYEwUjbYDAYEgQjbYPBYEgQjLQNBoMhQTDSNhgMhgTBSNtgMBgSBCNt\ng8FgSBCMtA0GgyFBCKzNlcFgMCQHZmkbDAZDgmCkbTAYDAmCkbbBYDAkCEbaBoPBkCAYaRsMBkOC\nYKRtMBgMCYKRtsFgMCQIRtoGg8GQIBhpGwwGQ4JgpG0wGAwJgpG2wWAwJAhG2gaDwZAgGGkbDAZD\ngmCkbTAYDAmCkbbBYDAkCEbaBoPBkCAYaRsMBkOCYKRtMBgMCYKRtsFgMCQIRtoGg8GQIPx/oFTB\nBoHG4d4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1deb0bb37b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAW0AAADDCAYAAABJYEAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1deb0bb3b00>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "digitA = 3\n",
    "digitB = 8\n",
    "\n",
    "digitA_index = label_dict[digitA]\n",
    "digitB_index = label_dict[digitB]\n",
    "\n",
    "imgA = img_data[digitA_index[0],:,:][0] \n",
    "imgB = img_data[digitB_index[0],:,:][0]\n",
    "\n",
    "# Print distance between original image\n",
    "imgA_B_dist = image_pair_cosine_distance(imgA, imgB)\n",
    "print(\"Distance between two original image: {0:.3f}\".format(imgA_B_dist))\n",
    "    \n",
    "# Plot the two images\n",
    "img1 = imgA.reshape(28,28)\n",
    "text1 = 'Original image 1'\n",
    "\n",
    "img2 = imgB.reshape(28,28)\n",
    "text2 = 'Original image 2'\n",
    "\n",
    "plot_image_pair(img1, text1, img2, text2)\n",
    "    \n",
    "# Decode the encoded stream \n",
    "imgA_decoded =  model.eval([imgA])[0]\n",
    "imgB_decoded =  model.eval([imgB])[0]    \n",
    "imgA_B_decoded_dist = image_pair_cosine_distance(imgA_decoded, imgB_decoded)\n",
    "\n",
    "#Print distance between original image\n",
    "print(\"Distance between two decoded image: {0:.3f}\".format(imgA_B_decoded_dist))\n",
    "\n",
    "# Plot the original and the decoded image\n",
    "img1 = imgA_decoded.reshape(28,28)\n",
    "text1 = 'Decoded image 1'\n",
    "\n",
    "img2 = imgB_decoded.reshape(28,28)\n",
    "text2 = 'Decoded image 2'\n",
    "\n",
    "plot_image_pair(img1, text1, img2, text2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print the results of the deep encoder test error for regression testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.11674596981\n"
     ]
    }
   ],
   "source": [
    "# Simple autoencoder test error\n",
    "print(simple_ae_test_error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.43888063784\n"
     ]
    }
   ],
   "source": [
    "# Deep autoencoder test error\n",
    "print(deep_ae_test_error)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Suggested tasks\n",
    "\n",
    "- Try different activation functions.\n",
    "- Find which images are more similar to one another (a) using original image and (b) decoded image.\n",
    "- Try using mean square error as the loss function. Does it improve the performance of the encoder in terms of reduced errors.\n",
    "- Can you try different network structure to reduce the error further. Explain your observations.\n",
    "- Can you use a different distance metric to compute similarity between the MNIST images.\n",
    "- Try a deep encoder with [1000, 500, 250, 128, 64, 32]. What is the training error for same number of iterations? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}