chapter9/astroml_chapter9_Deep_Learning_Classifying_Astronomical_Images.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Deep Learning: Classifying Astronomical Images \n",
    "\n",
    "<!---\n",
    "### January 6, 2020 \n",
    "\n",
    "\n",
    "[astroML workshop at the 235th Meeting of the American Astronomical Society](http://www.astroml.org/workshops/AAS235.html)\n",
    "--->\n",
    "[Andrew Connolly, University of Washington](http://faculty.washington.edu/ajc26/)\n",
    "\n",
    "Thanks to Hayden Smotherman, University of Washington for the example networks.\n",
    "\n",
    "\n",
    "In this notebook we work through a simple example for a Neural Network using TensorFlow and the Keras interface. Initially we will start with a vanila network with two hidden layers and then expand this to a convolutional neural network with drop out layers and batch normalization\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deep learning, an extension of the neural networks that were\n",
    "popularized in the 1990s. The concepts are inspired\n",
    "by the structure and function of the brain. A neuron in the brain is a\n",
    "core computational unit that takes a series of inputs from branched\n",
    "extensions of the neuron called dendrites, operates on these inputs,\n",
    "and generates an output that is transmitted along an axon to one or\n",
    "more other neurons. In the context of a neural network a neuron, $j$, takes a set of inputs,\n",
    "$x_i$, applies a, typically non-linear, function to these inputs and\n",
    "generates an output value. Networks are then created by connecting\n",
    "multiple neurons or layers of neurons to one another."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Neural Network Diagram](figures/fig_neural_network-1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we consider the simplified network\n",
    "inputs are passed to the neurons in the\n",
    "network. Each input is weighted by a value, $w_{ij}$ and the sum of\n",
    "these weighted inputs is operated on by a response or activation\n",
    "function $f(\\theta)$, which transform\n",
    "the input signal so that it varies between 0 and 1 through the\n",
    "application of a non-linear response. The output from any neuron is\n",
    "then given by,\n",
    "\n",
    "$$\n",
    "a_j =  f  \\left( \\sum_i w_{ij} x_i + b_j \\right)\n",
    "$$\n",
    "\n",
    "where $b_j$ is a bias term which determines the input level at which the\n",
    "neuron becomes activated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We refer to the neurons between the inputs and the output layers as\n",
    "the hidden layers. If the neurons from one layer connect to all\n",
    "neurons in a subsequent layer we call this a fully connected layer.\n",
    "When the outputs from the neurons only connect to subsequent layers\n",
    "(i.e. the graph is acyclic) we refer to this as a feed-forward\n",
    "network -- this is the most common\n",
    "structure for a neural network used in classification. \n",
    "\n",
    "The final layer in the network is the output layer. As with the hidden\n",
    "layer, an activation function, $g(\\theta)$, in the output layer acts\n",
    "on the weighted sum of its inputs.  In this figure we have a single\n",
    "output node but there can be multiple outputs. For our example  network the\n",
    "output from the final neuron, $y_k$, would be given by\n",
    "\n",
    "$$\n",
    "y_k = g \\left( \\sum_j   w_{jk} a_j  + b_k \\right)  = g\\left( \\sum_j\n",
    "  w_{jk}  f \\left( \\sum_i w_{ij} x_i + b_j\\right) + b_k\\right)\n",
    "$$\n",
    "\n",
    "**Training of the network is simply the learning of the weights and bias values**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to reduce the deprecation warnings\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Enabling eager execution\n",
      "INFO:tensorflow:Enabling v2 tensorshape\n",
      "INFO:tensorflow:Enabling resource variables\n",
      "INFO:tensorflow:Enabling tensor equality\n",
      "INFO:tensorflow:Enabling control flow v2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[name: \"/device:CPU:0\"\n",
       " device_type: \"CPU\"\n",
       " memory_limit: 268435456\n",
       " locality {\n",
       " }\n",
       " incarnation: 17111024148454857511]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#check we have a GPU available\n",
    "from tensorflow.python.client import device_lib\n",
    "device_lib.list_local_devices()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from astroML.utils import split_samples\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading some visualization and helper functions\n",
    "\n",
    "These functions  ```normalize_image```, ```plot_image_array```, ```plot_confusion_matrix```, ```plot_model_history``` will be used to visualize the data and the outputs of the neural networks as a function of the type and complexity of the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.set_printoptions(precision=2)\n",
    "\n",
    "def normalize_image(image):\n",
    "    '''Rescale the constrast in an image based on the noise (used for displays and the CNN)'''\n",
    "    sigmaG_coeff =  0.7413\n",
    "    image = image.reshape(21,21)\n",
    "    \n",
    "    per25,per50,per75 = np.percentile(image,[25,50,75])\n",
    "    sigmaG = sigmaG_coeff * (per75 - per25)\n",
    "    # sigma clip image, remove background, and normalize to unity\n",
    "    image[image<(per50-2*sigmaG)] = per50-2*sigmaG\n",
    "    image -= np.min(image)\n",
    "    image /= np.sum(image)\n",
    "    \n",
    "    return image\n",
    "    \n",
    "def plot_image_array(images, nrows=2, ncols=5, figsize=[8,4], nx=21, ny=21, title='', subtitle=False, \n",
    "                     class_true=None, classes=None):\n",
    "    '''Plot an array of images'''\n",
    "    fig, ax = plt.subplots(nrows=nrows,ncols=ncols,figsize=figsize)\n",
    "    fig.subplots_adjust(hspace=0, left=0.07, right=0.95, wspace=0.05, bottom=0.15)\n",
    "    for indx in np.arange(nrows*ncols):\n",
    "        i = int(indx/ncols)\n",
    "        j = indx%ncols\n",
    "        if (i == 0):\n",
    "            ax[i][j].xaxis.set_major_formatter(plt.NullFormatter())\n",
    "        if (j != 0):\n",
    "            ax[i][j].yaxis.set_major_formatter(plt.NullFormatter())\n",
    "\n",
    "        ax[i][j].imshow(images[indx].reshape(nx,ny), cmap='gray')\n",
    "        if (subtitle == True):\n",
    "            ax[i][j].set_title('True Class: %i, Predicted Class: %i\\n  Prob Class 1 %e ' % \n",
    "              (np.argmax(class_true[indx]), np.argmax(classes[indx]), classes[indx,1]))\n",
    "\n",
    "    fig.suptitle(title)\n",
    "    ax[0][0].set_ylabel('$y$')\n",
    "    ax[nrows-1][int(ncols/2)].set_xlabel('$x$')            \n",
    "    \n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.utils.multiclass import unique_labels\n",
    "\n",
    "def plot_confusion_matrix(y_true, y_pred, \n",
    "                          normalize=False,\n",
    "                          title=None,\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    From scikit-learn: plots a confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if not title:\n",
    "        if normalize:\n",
    "            title = 'Normalized confusion matrix'\n",
    "        else:\n",
    "            title = 'Confusion matrix, without normalization'\n",
    "\n",
    "    # Compute confusion matrix\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "    im = ax.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "\n",
    "    ax.set(xticks=np.arange(cm.shape[1]),\n",
    "           yticks=np.arange(cm.shape[0]),\n",
    "           # ... and label them with the respective list entries\n",
    "           title=title,\n",
    "           ylabel='True label',\n",
    "           xlabel='Predicted label')\n",
    "\n",
    "    # Rotate the tick labels and set their alignment.\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
    "             rotation_mode=\"anchor\")\n",
    "\n",
    "    #fixes \"squishing of plot\"\n",
    "    plt.ylim([1.5, -.5]) \n",
    "    \n",
    "    # Loop over data dimensions and create text annotations.\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i in range(cm.shape[0]):\n",
    "        for j in range(cm.shape[1]):\n",
    "            ax.text(j, i, format(cm[i, j], fmt),\n",
    "                    ha=\"center\", va=\"center\",\n",
    "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "    fig.tight_layout()\n",
    "\n",
    "def plot_model_history(history):\n",
    "    '''Plot the training and validation history for a TensorFlow network'''\n",
    "\n",
    "    # Extract loss and accuracy\n",
    "    loss = history.history['loss']\n",
    "    val_loss = history.history['val_loss']\n",
    "    acc = history.history['accuracy']\n",
    "    val_acc = history.history['val_accuracy']\n",
    "    \n",
    "    fig, ax = plt.subplots(nrows=1,ncols=2, figsize=(10,5))\n",
    "    ax[0].plot(np.arange(n_epochs), loss, label='Training Loss')\n",
    "    ax[0].plot(np.arange(n_epochs), val_loss, label='Validation Loss')\n",
    "    ax[0].set_title('Loss Curves')\n",
    "    ax[0].legend()\n",
    "    ax[0].set_xlabel('Epoch')\n",
    "    ax[0].set_ylabel('Loss')\n",
    "\n",
    "    ax[1].plot(np.arange(n_epochs), acc, label='Training Accuracy')\n",
    "    ax[1].plot(np.arange(n_epochs), val_acc, label='Validation Accuracy')\n",
    "    ax[1].set_title('Accuracy Curves')\n",
    "    ax[1].legend()\n",
    "    ax[1].set_xlabel('Epoch')\n",
    "    ax[1].set_ylabel('Accuracy')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the training samples and create test and validation data sets\n",
    "\n",
    "The data we are using is taken from a survey for NEOs by Lori Allen and collaborators using DECam on the Blanco 4m Telescope at CTIO. The data comprise a stack of images taken over a period of 5 nights. Within these images we search for slowly moving sources (TNOs) along potential orbital trajectories. Given these trajectories we coadd the images. Our goal is to determine whether there is a point source within the coadded images. The training sample includes images of simulated TNOs (true positives; stamps_sources.npz) and random trajectories where there is no known source (false positives; stamps_noise.npz). The true positives range in signal-to-noise from 100 to 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading file data/stamps_noise.npy.\n",
      "File data/stamps_noise.npy is downloaded\n",
      "Downloading file data/stamps_sources.npy.\n",
      "File data/stamps_sources.npy is downloaded\n"
     ]
    }
   ],
   "source": [
    "# Brute force direct downloads source and noise images to circumvent size limitations \n",
    "# for google drive internal virus scan. Download may take some time.\n",
    "\n",
    "import os\n",
    "import requests\n",
    "\n",
    "files = {'sources': (os.path.join('data', 'stamps_noise.npy'), '1UT2BCf-IDUEpvTmcU4bq6nDcY3Ayw5vJ'),\n",
    "         'noise': (os.path.join('data', 'stamps_sources.npy'), '1cZaMCA0z_nPX6GB_meLGouwOidEROcwc')}\n",
    "\n",
    "for name, file_id in files.values():\n",
    "    if not os.path.exists(name):\n",
    "        print(f\"Downloading file {name}.\")\n",
    "        \n",
    "        os.makedirs(os.path.dirname(name), exist_ok=True)\n",
    "        url = f\"https://docs.google.com/uc?export=download&id={file_id}&confirm=t\"\n",
    "        response = requests.post(url)\n",
    "        with open(name, 'wb') as file:\n",
    "            file.write(response.content) \n",
    "    print(f\"File {name} is downloaded\")\n",
    "            \n",
    "sources = np.load(files['sources'][0])\n",
    "noise = np.load(files['noise'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# normalizing images\n",
    "\n",
    "point_source_stamps = []\n",
    "for image in sources:\n",
    "    point_source_stamps.append(normalize_image(image))\n",
    "\n",
    "no_point_source_stamps = []\n",
    "for image in noise:\n",
    "    no_point_source_stamps.append(normalize_image(image))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot sample of images\n",
    "plot_image_array(no_point_source_stamps, title='false positives')\n",
    "plot_image_array(point_source_stamps, title='true positives')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a training, validation, and test sample\n",
    "\n",
    "We will use astroML's split_samples to do this ```split_samples(input_stamps, stamp_class, [0.7,0.1,0.2])``` breaks the data in to random selections with  appropriate fractions of sources"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of samples in the training (76666); test (21905); and validation (10952) data sets\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.utils import to_categorical\n",
    "def reshape_arrays(data, labels):\n",
    "    '''reshape arrays for Keras'''\n",
    "    data = data.reshape(-1,21, 21, 1) \n",
    "    labels = to_categorical(labels)\n",
    "    return data,labels\n",
    "\n",
    "# combine the false positives and true positives\n",
    "input_stamps = np.vstack([no_point_source_stamps, point_source_stamps])\n",
    "stamp_class = np.zeros(len(no_point_source_stamps) + len(point_source_stamps))\n",
    "stamp_class[len(no_point_source_stamps):] = 1 # 0 for noise, 1 for a star\n",
    "\n",
    "# split the samples into training, validation and test data sets\n",
    "(data_train, data_val, data_test), (class_train, class_val, class_test) = split_samples(input_stamps, stamp_class, \n",
    "                                                                                        [0.7,0.1,0.2])\n",
    "data_train, class_train = reshape_arrays(data_train, class_train)\n",
    "data_val, class_val = reshape_arrays(data_val, class_val)\n",
    "data_test, class_test = reshape_arrays(data_test, class_test)\n",
    "\n",
    "print ('Number of samples in the training ({}); test ({}); and validation ({}) data sets'.format(data_train.shape[0], \n",
    "                                                                                    data_test.shape[0],\n",
    "                                                                                   data_val.shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Network Frameworks\n",
    "\n",
    "\n",
    "The development and release of open source deep learning libraries has\n",
    "made the use of deep neural networks accessible to a wide range of\n",
    "fields. Currently there are two common packages PyTorch (https://pytorch.org) and Tensorflow (https://www.tensorflow.org). Either code base can be utilized for the\n",
    "figures and problems in this book (and generally they have the same\n",
    "functionality). \n",
    "\n",
    "### TensorFlow:\n",
    "\n",
    "Tensorflow is the more established code base with a large community\n",
    "and a large number of tutorials (https://www.tensorflow.org/tutorials) and online courses. Its\n",
    "functionality is more developed than PyTorch with tools to visualize\n",
    "and inspect a network (e.g., see TensorBoard). On the other hand, the\n",
    "learning curve for PyTorch is generally considered to be easier than\n",
    "that for Tensorflow with PyTorch having a more natural object oriented\n",
    "interface for people used to writing Python code.\n",
    "\n",
    "### PyTorch:\n",
    "\n",
    "The primary difference between TensorFlow and PyTorch is that the\n",
    "networks (or graphs) that TensorFlow generates are static while the\n",
    "networks for PyTorch are dynamic (see TensorFlow Fold for dynamic graphs). This means that with PyTorch one can\n",
    "modify and adjust the network on-the-fly (e.g., making it easier to\n",
    "adjust for changes in the input dimensionality or number of input\n",
    "nodes within a network). This feature and the object-oriented design of\n",
    "PyTorch often results in fewer lines of code to achieve the same\n",
    "solution when compared to Tensorflow.\n",
    "\n",
    "### Keras:  \n",
    "\n",
    "Keras is a high-level API written on top of TensorFlow (and its precursor Theano). It is written in Python and provides a simple and intuitive interface when building neural networks. It is currently released as part of TensorFlow.\n",
    "\n",
    "**What should you choose?** Both frameworks are continuously evolving.\n",
    "The choice of deep learning library will\n",
    "likely come down to which one you find better fits your style of\n",
    "programming and learning. For this tutorial we will use Keras as it has an intuitive implementation of the graphical or network models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building a network:\n",
    "\n",
    "Let's start by defining what we need for the network. We will start with Keras and\n",
    "\n",
    "- create a sequential model (this means we add layers one-by-one as we see in our introductory figure)\n",
    "- add a dense (fully connected) layer with 30 neurons \n",
    "  - **input_shape** describes the dimensionality of the _input data_ to this first hidden layer\n",
    "  - **activation** describes the activation fuction for the neurons (in this case we will be using 'relu'; rectified linear unit)\n",
    "- add a second dense (fully connected) layer with 30 neurons\n",
    "- flatten the output of the second layer into a single vector so we can use ```categorical_crossentropy``` as we are assuming that our classes are \"one-hot encoding\" (i.e. [1,0] or [0,1]\n",
    "- add an output layer using \"softmax\" (this means the activation values for each class sum to 1 so they can be treated like probabilities) with 2 nodes (_for our example we could have used a single output_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training the network\n",
    "Training a neural network is conceptually simple. Given a labelled set\n",
    "of data and a loss function, we need to optimize\n",
    "the weights and biases within the network by minimizing the loss.  A solution for training large\n",
    "networks\n",
    "uses backpropagation to efficiently estimate the gradient of the loss\n",
    "function with respect\n",
    "to the weights and biases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a Neural Network with Keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Conv2D, Flatten, Activation\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "\n",
    "def simple(input_shape=(21, 21, 1), n_classes: int = 2):\n",
    "\n",
    "    model = tf.keras.models.Sequential(name='simple')\n",
    "\n",
    "    # input: 21x21 images with 1 channel -> (21, 21, 1) tensors.\n",
    "    model.add(tf.keras.layers.Dense(30, input_shape=input_shape, activation='relu', name='fc_1'))\n",
    "        \n",
    "    model.add(tf.keras.layers.Dense(30, activation='relu', name='fc_2'))\n",
    "\n",
    "    # output layer\n",
    "    model.add(tf.keras.layers.Flatten())\n",
    "    activation = 'sigmoid' if n_classes == 1 else 'softmax'\n",
    "    model.add(tf.keras.layers.Dense(n_classes, activation=activation, name='fc_out'))\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"simple\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "fc_1 (Dense)                 (None, 21, 21, 30)        60        \n",
      "_________________________________________________________________\n",
      "fc_2 (Dense)                 (None, 21, 21, 30)        930       \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 13230)             0         \n",
      "_________________________________________________________________\n",
      "fc_out (Dense)               (None, 2)                 26462     \n",
      "=================================================================\n",
      "Total params: 27,452\n",
      "Trainable params: 27,452\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "#output the structure of the model\n",
    "simple_model = simple()\n",
    "simple_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "76666/76666 [==============================] - 66s 857us/step - loss: 0.6549 - accuracy: 0.5892 - val_loss: 0.6911 - val_accuracy: 0.5540\n"
     ]
    }
   ],
   "source": [
    "n_epochs=1\n",
    "batch_size=1\n",
    "simple_model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])\n",
    "simple_model_history = simple_model.fit(data_train, class_train, epochs=n_epochs, batch_size=batch_size,  verbose=1, \n",
    "                                        validation_data=(data_val, class_val), shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise\n",
    "\n",
    "**Mini-batch:** Optimization of the weights uses a standard gradient descent technique. If the loss function can be expressed in terms of a sum over subsets of the training data (e.g., as is the case for the\n",
    "L2 norm) the training can be undertaken either for the dataset as a\n",
    "whole, for subsets of the data (batch learning), or for individual\n",
    "entries (on-line or stochastic learning). _Batch gradient descent_ looks at all points in the data and calculates the average gradients before updating the weights in the model. _Stochastic gradient descent_ takes a single point and calculates the gradients and then updates the model (and then repeats). _Mini-batch gradient descent_ takes a subset of the training data and  calculates the average gradients and  updates the model  (and then repeats over all mini-batches)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_epochs=20\n",
    "batch_size=\n",
    "simple_model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])\n",
    "simple_model_history = simple_model.fit(data_train, class_train, epochs=n_epochs, batch_size=batch_size,  verbose=1, \n",
    "                                        validation_data=(data_val, class_val), shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performance of the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.41 0.59]\n",
      " [0.41 0.59]\n",
      " [0.41 0.59]\n",
      " ...\n",
      " [0.41 0.59]\n",
      " [0.41 0.59]\n",
      " [0.41 0.59]]\n"
     ]
    }
   ],
   "source": [
    "# use the network to predict class values\n",
    "classes = simple_model.predict(data_test)\n",
    "print (classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the confusion matrix\n",
    "plot_confusion_matrix(np.argmax(class_test,axis=1), np.argmax(classes,axis=1), normalize=True,\n",
    "                      title='Normalized confusion matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the training history of the network\n",
    "plot_model_history(simple_model_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Batch normalization\n",
    "\n",
    "Our first optimization over the vanila NN. Batch normalization scales the activations from a layer (note we normalized the input data) to have zero mean and unit variance. In reality, the two parameters gamma (for the standard deviation) and beta (for the mean) are learned by the network and the activations multiplied/added by these parameters. Batch normalization provides a degree of regularization and allows for faster learning rates as the outputs are constrained to 0-1 (i.e. you dont get large excursions in the weights of subsequent layers in a network that need to be reoptimized/trained). \n",
    "\n",
    "The normalization is applied to mini-batches of training data (as opposed to using the full training sample)\n",
    "- add a batch normalization layer:  ```model.add(tf.keras.layers.BatchNormalization(axis = 3, name = 'bn_1'))```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simpleBN(input_shape=(21, 21, 1), n_classes: int = 2):\n",
    "\n",
    "    model = tf.keras.models.Sequential(name='simple')\n",
    "\n",
    "    # input: 21x21 images with 1 channel -> (21, 21, 1) tensors.\n",
    "    model.add(tf.keras.layers.Dense(30, input_shape=input_shape, activation='relu', name='fc_1'))\n",
    "        \n",
    "    model.add(tf.keras.layers.Dense(30, activation='relu', name='fc_2'))\n",
    "\n",
    "    # output layer\n",
    "    model.add(tf.keras.layers.Flatten())\n",
    "    activation = 'sigmoid' if n_classes == 1 else 'softmax'\n",
    "    model.add(tf.keras.layers.Dense(n_classes, activation=activation, name='fc_out'))\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "300/300 [==============================] - 12s 39ms/step - loss: 0.6903 - accuracy: 0.5446 - val_loss: 0.6881 - val_accuracy: 0.5499\n",
      "Epoch 2/20\n",
      "300/300 [==============================] - 13s 44ms/step - loss: 0.6887 - accuracy: 0.5467 - val_loss: 0.6881 - val_accuracy: 0.5499\n",
      "Epoch 3/20\n",
      "300/300 [==============================] - 12s 41ms/step - loss: 0.6883 - accuracy: 0.5485 - val_loss: 0.6880 - val_accuracy: 0.5499\n",
      "Epoch 4/20\n",
      "300/300 [==============================] - 10s 35ms/step - loss: 0.6889 - accuracy: 0.5453 - val_loss: 0.6879 - val_accuracy: 0.5499\n",
      "Epoch 5/20\n",
      "300/300 [==============================] - 12s 39ms/step - loss: 0.6881 - accuracy: 0.5489 - val_loss: 0.6878 - val_accuracy: 0.5499\n",
      "Epoch 6/20\n",
      "300/300 [==============================] - 12s 38ms/step - loss: 0.6887 - accuracy: 0.5454 - val_loss: 0.6878 - val_accuracy: 0.5499\n",
      "Epoch 7/20\n",
      "300/300 [==============================] - 12s 39ms/step - loss: 0.6881 - accuracy: 0.5481 - val_loss: 0.6878 - val_accuracy: 0.5499\n",
      "Epoch 8/20\n",
      "300/300 [==============================] - 12s 40ms/step - loss: 0.6883 - accuracy: 0.5469 - val_loss: 0.6877 - val_accuracy: 0.5499\n",
      "Epoch 9/20\n",
      "300/300 [==============================] - 12s 39ms/step - loss: 0.6878 - accuracy: 0.5495 - val_loss: 0.6877 - val_accuracy: 0.5499\n",
      "Epoch 10/20\n",
      "300/300 [==============================] - 12s 40ms/step - loss: 0.6879 - accuracy: 0.5483 - val_loss: 0.6876 - val_accuracy: 0.5499\n",
      "Epoch 11/20\n",
      "300/300 [==============================] - 12s 40ms/step - loss: 0.6878 - accuracy: 0.5487 - val_loss: 0.6875 - val_accuracy: 0.5499\n",
      "Epoch 12/20\n",
      "300/300 [==============================] - 11s 36ms/step - loss: 0.6879 - accuracy: 0.5477 - val_loss: 0.6873 - val_accuracy: 0.5499\n",
      "Epoch 13/20\n",
      "300/300 [==============================] - 13s 42ms/step - loss: 0.6882 - accuracy: 0.5456 - val_loss: 0.6873 - val_accuracy: 0.5499\n",
      "Epoch 14/20\n",
      "300/300 [==============================] - 12s 40ms/step - loss: 0.6874 - accuracy: 0.5495 - val_loss: 0.6874 - val_accuracy: 0.5499\n",
      "Epoch 15/20\n",
      "300/300 [==============================] - 12s 39ms/step - loss: 0.6871 - accuracy: 0.5511 - val_loss: 0.6871 - val_accuracy: 0.5499\n",
      "Epoch 16/20\n",
      "300/300 [==============================] - 12s 39ms/step - loss: 0.6870 - accuracy: 0.5505 - val_loss: 0.6871 - val_accuracy: 0.5499\n",
      "Epoch 17/20\n",
      "300/300 [==============================] - 12s 40ms/step - loss: 0.6881 - accuracy: 0.5440 - val_loss: 0.6870 - val_accuracy: 0.5499\n",
      "Epoch 18/20\n",
      "300/300 [==============================] - 12s 41ms/step - loss: 0.6874 - accuracy: 0.5475 - val_loss: 0.6869 - val_accuracy: 0.5499\n",
      "Epoch 19/20\n",
      "300/300 [==============================] - 12s 39ms/step - loss: 0.6873 - accuracy: 0.5477 - val_loss: 0.6868 - val_accuracy: 0.5499\n",
      "Epoch 20/20\n",
      "300/300 [==============================] - 12s 39ms/step - loss: 0.6869 - accuracy: 0.5493 - val_loss: 0.6867 - val_accuracy: 0.5499\n"
     ]
    }
   ],
   "source": [
    "n_epochs=20\n",
    "simple_model = simpleBN()\n",
    "simple_model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])\n",
    "simple_model_history = simple_model.fit(data_train, class_train, epochs=n_epochs, batch_size=256, verbose=1, \n",
    "                                        validation_data=(data_val, class_val), shuffle=True)\n",
    "classes = simple_model.predict(data_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot normalized confusion matrix\n",
    "plot_confusion_matrix(np.argmax(class_test,axis=1), np.argmax(classes,axis=1), normalize=True,\n",
    "                      title='Normalized confusion matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAAFNCAYAAACJ9PI3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABlZklEQVR4nO3dd3gWVfbA8e9JgdAJvffeAiQ06WJBQXoVFFRQWYrgWtBdFV1dsexvlRVFigULQVEQFGWpgiBC6F1agABSQu8p5/fHTLIvMUAg5c2bnM/zvE9m7szcORPgct57Z+6IqmKMMcYYY3yXn7cDMMYYY4wxqWMJnTHGGGOMj7OEzhhjjDHGx1lCZ4wxxhjj4yyhM8YYY4zxcZbQGWOMMcb4OEvojDHGGGN8nCV0JsOISKSI3OGlczcWkbkickpETojIKhF5yBuxGGO8T0SWiMhJEcnp7VjSi4jkF5F3RGS/iJwTkd3uehFvx2bSniV0JssTkWbAIuBnoApQGBgC3HOL9fmnXXTGmIwmIhWAloACnTL43AEZdJ4cwEKgNtAeyA80A6KBxrdQX4bEbW6dJXTG60Qkp/ut8ZD7eSfhW7OIFBGR7z161paJiJ+77VkROSgiZ0Vkh4i0u8Yp3gI+VdU3VPW4Otaoai+3noEi8kuSmFREqrjLn4jIB24P33ngKRH5wzOxE5GuIrLRXfYTkdHut+FoEflKRAq524JE5HO3/JSIrBaR4mn8KzXGXN+DwErgE2CA5wYRKSsi34rIMfff6Xse2waLyDa3zdkqIg3d8sT2wl3/RERedZfbiEiU2179AXwsIsFuu3bM7SX8XkTKeBxfSEQ+dtvDkyIyyy3fLCL3eewXKCLHRaTBNa6xHNBVVbeqaryqHlXVf6jq3FuMe5uIdPTYP8C9hoTfQ1MRWeG2bRtEpI3HvgNFZI/7u9srIv1S9kdlUsoSOpMZ/A1oCtQHQnC+Pf7d3fZXIAooChQHngdURKoDw4BGqpoPuBuITFqxiOTG+VY6I5Ux3g+8BuQD3gXOA7cn2f6luzwc6AK0BkoBJ4Hx7rYBQAGgLE5P4ePAxVTGZoy5OQ8CX7ifuxO+VLlf0r4H9gEVgNJAuLutJzDGPTY/Ts9edArPVwIoBJQHHsX5v/djd70cThvwnsf+nwG5cXrXigH/dsunAv099rsXOKyq65I55x3AT6p6LoUxpiTuaUBfj+13A8dVda2IlAZ+AF51j3kK+EZEiopIHmAccI/bXt8GrE9FXCYZltCZzKAf8Ir77fEY8DLwgLstBigJlFfVGFVdps4LiOOAnEAtEQlU1UhV3Z1M3cE4f88PpzLG71R1ufst9xIeDZuI5MNpWKe5+z4O/E1Vo1T1Ms5/Aj3cIYsYnESuiqrGuT2FZ1IZmzEmhUSkBU6C8pWqrgF243whA+fLZCngaVU9r6qXVDWh934Q8KaqrnZ7+Xep6r4UnjYeeElVL6vqRVWNVtVvVPWCqp7F+bLY2o2vJM7tII+r6km33fvZredz4F4Rye+uP4CT/CWnMKlv966KG+dLayf3izI4v7eEdq8/MFdV57rt5HwgAqdtTKirjojkUtXDqrollbGZJCyhM5lBKZxvxAn2uWXgDJfuAv7rdtePBlDVXcBInGTpqIiEi0gp/uwkTkNSMpUxHkiy/iXQzR0a7gas9WjcywMz3WGHU8A2nAS0OE7jOw8Id4dT3hSRwFTGZoxJuQHAf1X1uLv+Jf8bdi0L7FPV2GSOK4uT/N2KY+4XQcAZORCRD0Vkn4icAZYCBd0ewrLACVU9mbQSVT0ELAe6i0hBnMTvi2ucM5rUt3tXxe22u9uA+9ykrhP/G5koD/RMaPfctq8FUFJVzwO9cb7sHhaRH0SkRipjM0lYQmcyg0M4jUGCcm4ZqnpWVf+qqpVwGo8nE+6VU9UvVTXh27YCbyStWFUvAL8C3a9z/vM4wxsAiEiJZPbRJPVuxUk87+Hq4VZwkr97VLWgxydIVQ+637ZfVtVaOMMOHXGGcIwx6UxEcgG9gNbufbB/AKOAEBEJwfm3W06SfwDgAFD5GlVfwKMNwRmq9KRJ1v8KVAeaqGp+oFVCiO55CrkJW3I+xekN6wn8qqoHr7HfApzh5DzX2H4rccP/Ric6A1vdJA837s+StHt5VHUsgKrOU9U7cZLM7cCk68RlboEldCajBboPBiR8AnAaiL+791oUAV7EGVpARDqKSBUREeA0Tk9XvIhUF5Hb3R6ySzj3oMRf45zPAANF5GkRKezWGyIi4e72DUBtEakvIkE4vX4p8SXwBE5j/LVH+QTgNREp756rqIh0dpfbikhd95v4GZwh2GvFbYxJW11w2pBaOPfs1gdqAstwvlitwhmmHCsiedw2qrl77GScB6JCxVEl4d84zv1g94uIv4i0xx0+vY58OG3WKXEemHopYYOqHgZ+BN53H54IFJFWHsfOAhritD1Tr3OOz3CSrG9EpIY4D2sVFpHnRSRhGPRm4wbnnsK7cGYK8Pwi+zlOz93dbn1B7oMVZUSkuIh0dpPLy8A5rN1Lc5bQmYw2F6chS/iMwbmJNgLYCGwC1rplAFVxvmmew+lpe19VF+PcPzcWOA78gXPj8HPJnVBVV+A8wHA7sEdETgAT3VhQ1d+BV9zz7AR+Sa6eZEzDaQAXeQzfgPPQxGycYeKzOE/TNXG3lcB5QOMMztDFz1z7HhhjTNoaAHysqvtV9Y+ED84DCf1wesjuw5neaD/OA1m9AVT1a5x73b4EzuIkVoXcep9wjzvl1jPrBnG8A+TCab9WAj8l2f4Azpe97cBRnNtLcOO4CHwDVAS+vdYJ3Pt373DrmI/T5qwCigC/3WLcCQnnrzgjDNM9yg/g9No9DxzDSSafxskz/IAncUZeTuC0m0NudC5zc8S5v9wYY4wxvkBEXgSqqWr/G+5ssg2bKNAYY4zxEe4Q7SP8byYAYwAbcjXGGGN8gogMxhnK/FFVl3o7HpO52JCrMcYYY4yPsx46Y4wxxhgfZwmdMcYYY4yPy9YPRRQpUkQrVKjg7TCMMRlozZo1x1W1qLfjSC1rv4zJfq7XfmXrhK5ChQpERER4OwxjTAYSkZS+fzNTs/bLmOzneu2XDbkaY4wxxvg4S+iMMSYZItJeRHaIyC4RGZ3M9oEickxE1rufQR7b4jzKZ3uUVxSR39w6p4tIDrc8p7u+y91eIUMu0hiTZVhCZ4wxSbjv2h0P3IPz3s++IlIrmV2nq2p99zPZo/yiR3knj/I3gH+rahXgJM4Esbg/T7rl/3b3M8aYFMvW99AZkxIxMTFERUVx6dIlb4dibkJQUBBlypQhMDDwVg5vDOxS1T0AIhKO857Krbcaj4gIzvuE73eLPsV5l/EHbt1j3PIZwHsiImoThRpjUsgSOmNuICoqinz58lGhQgWc/5NNZqeqREdHExUVRcWKFW+litI4M/IniAKaJLNfdxFpBfwOjHJfUA4QJCIRQCwwVlVnAYWBU6oa61Fn6aTnU9VYETnt7n/8VoI3xmQ/NuRqzA1cunSJwoULWzLnQ0SEwoULp3ev6hyggqrWA+bj9LglKK+qYTi9ce+ISOW0OKGIPCoiESIScezYsbSo0hiTRVhCZ0wKWDLne1L5Z3YQKOuxXsYtS6Sq0ap62V2dDIR6bDvo/twDLAEaANFAQRFJGBnxrDPxfO72Au7+V1HViaoapqphRYv6/FR6xpg0ZAmdMZlcdHQ09evXp379+pQoUYLSpUsnrl+5cuW6x0ZERDBixIgbnuO2225Lk1iXLFlCx44d06QuL1sNVHWfSs0B9AFme+4gIiU9VjsB29zyYBHJ6S4XAZoDW9374RYDPdxjBgDfucuz3XXc7Yvs/jljzM2we+iMyeQKFy7M+vXrARgzZgx58+blqaeeStweGxtLQEDy/5TDwsIICwu74TlWrFiRJrFmFe59bMOAeYA/8JGqbhGRV4AIVZ0NjBCRTjj3yZ0ABrqH1wQ+FJF4nC/NY1U14WGKZ4FwEXkVWAdMccunAJ+JyC63rj7pfpHGmCzFEroUOHXhCj9u/oMWVYpQtlBub4djDAMHDiQoKIh169bRvHlz+vTpwxNPPMGlS5fIlSsXH3/8MdWrV2fJkiW8/fbbfP/994wZM4b9+/ezZ88e9u/fz8iRIxN77/Lmzcu5c+dYsmQJY8aMoUiRImzevJnQ0FA+//xzRIS5c+fy5JNPkidPHpo3b86ePXv4/vvvUxTvtGnT+Oc//4mq0qFDB9544w3i4uJ45JFHiIiIQER4+OGHGTVqFOPGjWPChAkEBARQq1YtwsPD0/NXeU2qOheYm6TsRY/l54DnkjluBVD3GnXuwXmCNmn5JaBnKkO+th9Hwx+b0q16Y0wqlKgL94xNdTWW0KXA6YsxPPftJl7tUof+Tct7OxxjAOfp2xUrVuDv78+ZM2dYtmwZAQEBLFiwgOeff55vvvnmT8ds376dxYsXc/bsWapXr86QIUP+NK3HunXr2LJlC6VKlaJ58+YsX76csLAwHnvsMZYuXUrFihXp27dviuM8dOgQzz77LGvWrCE4OJi77rqLWbNmUbZsWQ4ePMjmzZsBOHXqFABjx45l79695MyZM7HMGGPM9VlClwLlCuWmSN4crN1/0hK6bO7lOVvYeuhMmtZZq1R+Xrqv9k0f17NnT/z9/QE4ffo0AwYMYOfOnYgIMTExyR7ToUMHcubMSc6cOSlWrBhHjhyhTJkyV+3TuHHjxLL69esTGRlJ3rx5qVSpUuIUIH379mXixIkpinP16tW0adOGhJv4+/Xrx9KlS3nhhRfYs2cPw4cPp0OHDtx1110A1KtXj379+tGlSxe6dOly078Xk4w0+PZvjMnc7KGIFBARGpQLZt3+U94OxZhEefLkSVx+4YUXaNu2LZs3b2bOnDnXnK4jZ86cicv+/v7Exsbe0j5pITg4mA0bNtCmTRsmTJjAoEHOm7N++OEHhg4dytq1a2nUqFG6nd8YY7IS66FLoYblgpm/9QjR5y5TOG/OGx9gsqRb6UnLCKdPn6Z0aWeO2k8++STN669evTp79uwhMjKSChUqMH369BQf27hxY0aMGMHx48cJDg5m2rRpDB8+nOPHj5MjRw66d+9O9erV6d+/P/Hx8Rw4cIC2bdvSokULwsPDOXfuHAULFkzzazLGmKzEEroUCi0fDMC6/ae4o1ZxL0djzNWeeeYZBgwYwKuvvkqHDh3SvP5cuXLx/vvv0759e/LkyUOjRo2uue/ChQuvGsb9+uuvGTt2LG3btk18KKJz585s2LCBhx56iPj4eABef/114uLi6N+/P6dPn0ZVGTFihCVzxhiTApKdpzoKCwvTiIiIFO17KSaOOi/N49FWlXimfY10jsxkJtu2baNmzZreDsPrzp07R968eVFVhg4dStWqVRk1apS3w7qu5P7sRGSN+xYHn3Yz7ZcxJmu4Xvtl99ClUFCgP7VK5WfNvpPeDsUYr5g0aRL169endu3anD59mscee8zbIRljjHHZkOtNaFgumOmrDxAbF0+Av+XCJnsZNWpUpu+RM8aY7CpdsxIRaS8iO0Rkl4iMvsY+vURkq4hsEZEvPcrfdMu2icg4cV/MKCK9RWSju+0Nj/1zish091y/iUiFtL6ehuWDuRgTx/Y/zqZ11cYYY4wxtyzdEjoR8QfGA/cAtYC+IlIryT5VcWZab66qtYGRbvltOO8/rAfUARoBrUWkMPAW0M7dv4SItHOrewQ4qapVgH8Db5DGGpYrCGDDrsYYY4zJVNKzh64xsEtV96jqFSAc6Jxkn8HAeFU9CaCqR91yBYKAHEBOIBA4AlQCdqrqMXe/BUB3d7kz8Km7PANol9Crl1ZKF8xF8fw5WbvfEjpjjDHGZB7pmdCVBg54rEe5ZZ6qAdVEZLmIrBSR9gCq+iuwGDjsfuap6jZgF1BdRCqISADQBSib9HyqGgucBgonDUpEHhWRCBGJOHbsWNLN1yUiNCwXbAmdMcYYYzIVb9/ZHwBUBdoAfYFJIlJQRKoANYEyOIna7SLS0u3JGwJMB5YBkUDczZxQVSeqapiqhiW8iuhmNCwXzIETFzl6NvmZ+I1Ja23btmXevHlXlb3zzjsMGTLkmse0adOGhCkt7r333mTfiTpmzBjefvvt65571qxZbN26NXH9xRdfZMGCBTcRffKWLFlCx44dU12PMcYYR3omdAf5X+8ZOMnZwST7RAGzVTVGVfcCv+MkeF2Blap6TlXPAT8CzQBUdY6qNlHVZsAO95irzuf23hUAotP6ohq6Ewyv3Xcqras2Jll9+/YlPDz8qrLw8HD69u2bouPnzp17y5PzJk3oXnnlFe64445bqssYY0z6Sc+EbjVQVUQqikgOoA8wO8k+s3B65xCRIjhDsHuA/TgPQQSISCDQGtjm7lfM/RkM/AWY7NY1GxjgLvcAFmk6zJpcp3R+cvj7sc6GXU0G6dGjBz/88ANXrlwBIDIykkOHDtGyZUuGDBlCWFgYtWvX5qWXXkr2+AoVKnD8+HEAXnvtNapVq0aLFi3YsWNH4j6TJk2iUaNGhISE0L17dy5cuMCKFSuYPXs2Tz/9NPXr12f37t0MHDiQGTNmAM4bIRo0aEDdunV5+OGHuXz5cuL5XnrpJRo2bEjdunXZvn17iq912rRp1K1blzp16vDss88CEBcXx8CBA6lTpw5169bl3//+NwDjxo2jVq1a1KtXjz59+tzkb9UYY7KWdEvo3PvYhgHzcJKxr1R1i4i8IiKd3N3mAdEishXnnrmnVTUa56GG3cAmYAOwQVXnuMe86+6/HBirqgk9dFOAwiKyC3gSSHaalNTKGeBP7dI2wbDJOIUKFaJx48b8+OOPgNM716tXL0SE1157jYiICDZu3MjPP//Mxo0br1nPmjVrCA8PZ/369cydO5fVq1cnbuvWrRurV69mw4YN1KxZkylTpnDbbbfRqVMn3nrrLdavX0/lypUT97906RIDBw5k+vTpbNq0idjYWD744IPE7UWKFGHt2rUMGTLkhsO6CQ4dOsSzzz7LokWLWL9+PatXr2bWrFmsX7+egwcPsnnzZjZt2sRDDz0EwNixY1m3bh0bN25kwoQJN/U7NcaYrCZdJxZW1bnA3CRlL3osK07y9WSSfeKAZKehV9Vkx5lU9RLQM5Uhp0houWCmrtzHldh4cgR4+zZEk6F+HA1/bErbOkvUhXvGXneXhGHXzp07Ex4ezpQpUwD46quvmDhxIrGxsRw+fJitW7dSr169ZOtYtmwZXbt2JXfu3AB06tQpcdvmzZv5+9//zqlTpzh37hx33333dePZsWMHFStWpFq1agAMGDCA8ePHM3LkSMBJEAFCQ0P59ttvb/w7AFavXk2bNm1IuLe1X79+LF26lBdeeIE9e/YwfPhwOnTowF133QVAvXr16NevH126dKFLly4pOocxxmRVlo3cgoblg7kSG8/Ww2e8HYrJJjp37szChQtZu3YtFy5cIDQ0lL179/L222+zcOFCNm7cSIcOHbh06dYe1hk4cCDvvfcemzZt4qWXXrrlehLkzJkTAH9/f2JjY1NVV3BwMBs2bKBNmzZMmDCBQYMGAfDDDz8wdOhQ1q5dS6NGjVJ9HmOM8WX26q9b0LCc82DEmn0nqV+2oHeDMRnrBj1p6SVv3ry0bduWhx9+OPFhiDNnzpAnTx4KFCjAkSNH+PHHH2nTps0162jVqhUDBw7kueeeIzY2ljlz5iS+j/Xs2bOULFmSmJgYvvjiC0qXdmYYypcvH2fP/vnNKNWrVycyMpJdu3ZRpUoVPvvsM1q3bp2qa2zcuDEjRozg+PHjBAcHM23aNIYPH87x48fJkSMH3bt3p3r16vTv35/4+HgOHDhA27ZtadGiBeHh4Zw7d+6WH/4wxhhfZwndLShRIIjSBXOxdv9JHqGit8Mx2UTfvn3p2rVr4hOvISEhNGjQgBo1alC2bFmaN29+3eMbNmxI7969CQkJoVixYjRq1Chx2z/+8Q+aNGlC0aJFadKkSWIS16dPHwYPHsy4ceMSH4YACAoK4uOPP6Znz57ExsbSqFEjHn/88Zu6noULF1KmTJnE9a+//pqxY8fStm1bVJUOHTrQuXNnNmzYwEMPPUR8fDwAr7/+OnFxcfTv35/Tp0+jqowYMcKSOWNMtibp8CCozwgLC9OEubpu1rAv17J230lWPNfuxjsbn7Zt2zZq1qzp7TDMLUjuz05E1qhqmJdCSjOpab+MMb7peu2X3UN3ixqWC+bQ6UscPn3R26EYY4wxJpuzhO4WhdoEw8YYY4zJJCyhu0U1S+YnZ4CfvdfVGGOMMV5nCd0tyhHgR70yBWyC4WwiO99r6qvsz8wYk51YQpcKDcsHs+XQaS7FxHk7FJOOgoKCiI6OtgTBh6gq0dHRBAUFeTsUY4zJEDZtSSo0LBfMh3F72HLoNKHlC3k7HJNOypQpQ1RUFMeOHfN2KOYmBAUFXTUtijHGZGWW0KWC5wTDltBlXYGBgVSsaPMNGmOMybxsyDUViubLSblCue1JV2OMMcZ4lSV0qdSwXEHW7D9p91cZY4wxxmssoUulhuWDOXb2MlEnbYJhY4wxxniHJXSplHAfnc1HZ4wxxhhvsYQulWqUyEfuHP6s23/K26EYY4wxJpuyhC6VAvz9CClT0CYYNsYYY4zXWEKXBhqWL8i2w2e4eMUmGDbGGGNMxrOELg00LBdMbLyyMeqUt0MxxhhjTDZkCV0aaJAwwbA9GGGMMcYYL7CELg0UypODSkXy2ATDxhhjjPEKS+jSSINywayzCYaNMcYY4wWW0KWR0PLBRJ+/wr7oC94OxRiTBkSkvYjsEJFdIjI6me0DReSYiKx3P4OSbM8vIlEi8p5HWW8R2SgiW0TkjZTWZYwxN2IJXRppWL4gYBMMG5MViIg/MB64B6gF9BWRWsnsOl1V67ufyUm2/QNY6lFnYeAtoJ2q1gZKiEi7FNZljDHXZQldGqlaLB95cwZYQmdM1tAY2KWqe1T1ChAOdE7pwSISChQH/utRXAnYqarH3PUFQPc0itcYk81ZQpdG/P2EBuUKssYejDAmKygNHPBYj3LLkuruDqHOEJGyACLiB/wLeCrJvruA6iJSQUQCgC5A2evVZYwxKWUJXRpqUC6YHX+c4dzlWG+HYoxJf3OACqpaD5gPfOqW/wWYq6pRnjur6klgCDAdWAZEAnE3qOsqIvKoiESISMSxY8eS28UYk01ZQpeGGpYrSLzCxgOnvB2KMSZ1DnJ171kZtyyRqkar6mV3dTIQ6i43A4aJSCTwNvCgiIx1j5mjqk1UtRmwA/j9BnVdRVUnqmqYqoYVLVo0tddojMlCLKFLQ4kTDNt7XY3xdauBqiJSUURyAH2A2Z47iEhJj9VOwDYAVe2nquVUtQLOsOtUVR3tHlPM/RmM05M3+Xp1GWNMSgV4O4CspECuQKoWy2sPRhjj41Q1VkSGAfMAf+AjVd0iIq8AEao6GxghIp2AWOAEMDAFVb8rIiHu8iuq+ru7fCt1GWNMIkvo0ljDcsHM2/oH8fGKn594OxxjzC1S1bnA3CRlL3osPwc8d4M6PgE+8Vjve439bliXMcZcjw25prHQ8sGcuhDDnuPnvR2KMcYYY7IJS+jSmE0wbIwxxpiMZgldGqtUJC/5gwJYZwmdMcYYYzKIJXRpzM9PaFg+2J50NcYYY0yGsYQuHTQsF8zOo+c4cynG26EYY4wxJhuwhC4dNCwXjCqs23/K26EYY4wxJhuwhC4d1C9XkKBAPx7/bA0jpq1j/tYjXI6Nu/GBxhhjjDG3wOahSwd5cwYw4/Hb+HLVfn7cdJjZGw6RPyiA9nVK0CmkNE0rFSLA33JpY4wxxqQNS+jSSZ3SBfhn17q83Kk2v+w6zpwNh5i76Q++ioiiSN4cdKhbkvtCStGwXLBNQGyMMcaYVLGELp0F+vvRtnox2lYvxqWYOJbsOMrsDYcIX32AT3/dR+mCuehYz0nuapfKj4gld8YYY4y5Oek67ici7UVkh4jsEpHR19inl4hsFZEtIvKlR/mbbtk2ERknbqYjIn1FZJOIbBSRn0SkiFs+RkQOish693Nvel7brQgK9Kd9nZK83y+UNS/cyb97h1C9RD6m/LKXjv/5hd4frmTX0bPeDtMYY4wxPibdeuhExB8YD9wJRAGrRWS2qm712KcqzvsLm6vqSREp5pbfBjQH6rm7/gK0FpFfgHeBWqp6XETeBIYBY9z9/q2qb6fXNaWlvDkD6NqgDF0blOHk+St8t/4g/16wk3veXcaQ1pX5S9sqBAX6eztMY4wxxviA9OyhawzsUtU9qnoFCAc6J9lnMDBeVU8CqOpRt1yBICAHkBMIBI4A4n7yuD12+YFD6XgNGSI4Tw4GNq/Iwr+2pkPdkoxbtIt7313Git3HvR2aMcYYY3xAeiZ0pYEDHutRbpmnakA1EVkuIitFpD2Aqv4KLAYOu595qrpNVWOAIcAmnESuFjDFo75h7lDsRyISnC5XlY6K5M3JO30a8NkjjYlT5f5Jv/HXrzZw4vwVb4dmjDHGmEzM23NnBABVgTZAX2CSiBQUkSpATaAMThJ4u4i0FJFAnISuAVAK2IgzZAvwAVAZqI+TBP4ruROKyKMiEiEiEceOHUuv60qVllWLMm9kK4a2rcx36w/S7l9L+GZNFKrq7dCMMcYYkwmlZ0J3ECjrsV7GLfMUBcxW1RhV3Qv8jpPgdQVWquo5VT0H/Ag0w0nWUNXd6mQ3XwG3uWVHVDVOVeOBSThDvn+iqhNVNUxVw4oWLZpGl5r2ggL9efruGvwwoiWViublr19voN/k39h7/Ly3QzPGGGNMJpOeCd1qoKqIVBSRHEAfYHaSfWbh9M7hPq1aDdgD7Md5CCLA7ZVrDWzDSQhriUhCJnanW46IlPSotyuwOR2uKcNVL5GPrx9rxmtd67Dp4Gnufmcp/1m4kyux8d4OzRhjjDGZRLo95aqqsSIyDJgH+AMfqeoWEXkFiFDV2e62u0RkKxAHPK2q0SIyA7gd5145BX5S1TkAIvIysFREYoB9wED3lG+KSH13/0jgsfS6tozm5yf0a1KeO2sW5+Xvt/Kv+b/z3YZDvNK5NrdVLuLt8IwxxhjjZZKd78sKCwvTiIgIb4dx0xZvP8rfZ23m4KmLNKlYiJF3VKNZ5cLeDssYnyAia1Q1zNtxpJavtl/GmFt3vfbL2w9FmFvQtkYxFv61NS/dV4u9x8/Td9JKen34Kyt2HbcHJ4wxxphsyBI6HxUU6M9DzSuy9Jm2jLmvFvuiz3P/5N/o/eFKlltiZ4wxxmQrltD5uKBAfwY2r8jPT7fl5U612X/iAv0m/0bPCb/yy05L7IwxxpjswBK6LCIo0J8Bt1VgydNt+Efn2kSdvEj/Kb/RY8KvLP39mCV2xhhjTBZmCV0WExTozwPNKvDzM234R5c6HDp1kQc/WkW3D1awYpe9SswYY4zJiiyhy6JyBvjzQNPyLHm6Da92qcOR05e4f/JvjJm9hUsxcd4OzxhjjDFpyBK6LC5ngD/9m5Zn0VNteKh5BT5ZEUmX8cv5/chZb4dmjDHGmDRiCV02ERToz0v31ebjgY04dvYy9/3nFz77NdLurTPGGGOyAEvospm2NYrx48iWNK1UmBe+28LgqWs4cf6Kt8MyxhhjTCpYQpcNFcsXxMcDG/FCx1os/f0Y7d9Zyi877YEJY4wxxldZQpdN+fkJj7SoyMyht5E/VyD9p/zG63O3cSU23tuhGWOMMeYmWUKXzdUuVYA5w1rQr0k5Ply6h24fLGfPsXPeDssYY4wxN8ESOkOuHP681rUuHz4QStTJi3QY9wvTV++3ByaMMcYYH2EJnUl0d+0S/PREK+qXLciz32zi0c/WsGbfCUvsjDHGmEwuwNsBmMylRIEgPh/UhIlL9/Deop3M33qEasXz0qdRObo1LE3B3Dm8HaIxxhhjkrAeOvMn/n7CkDaVWfW3O3ije11y5Qjgle+30vifC3kifB0r90Rbr50xxhiTiVgPnbmmPDkD6N2oHL0blWPb4TOEr9rPt+sO8t36Q1Qqkoc+jcvSvWEZCufN6e1QjTHGmGzNeuhMitQsmZ+XO9dh1fN38K+eIRTOm4N/zt1O09cXMvSLtSzbeYz4eOu1M8YYY7zBeujMTcmVw5/uoWXoHlqGnUfOEr76AN+sjeKHTYcpVyg3DzQtT6+wshTIHejtUI0xxphsw3rozC2rWjwfL3Ssxcrn2vFun/qUKBDEa3O30fT1hTz37SZ2/HHW2yEac8tEpL2I7BCRXSIyOpntA0XkmIisdz+DkmzPLyJRIvKeR1lvEdkoIltE5A2P8pwiMt09128iUiFdL84Yk+VYD51JtaBAfzrXL03n+qXZeugMn66I5Nu1UUxbtZ9mlQoz4LYK3FmrOP5+4u1QjUkREfEHxgN3AlHAahGZrapbk+w6XVWHXaOafwBLPeosDLwFhKrqMRH5VETaqepC4BHgpKpWEZE+wBtA7zS+LGNMFmY9dCZN1SqVnzd61GPlc+14tn0N9p+4wOOfr6HVm4uZ8PNuTl244u0QjUmJxsAuVd2jqleAcKBzSg8WkVCgOPBfj+JKwE5VPeauLwC6u8udgU/d5RlAOxGxb0DGmBSzhM6ki+A8ORjSpjI/P92GCf1DKVsoF2N/3E6Tfy5k9Dcb2Xb4jLdDNOZ6SgMHPNaj3LKkurtDqDNEpCyAiPgB/wKeSrLvLqC6iFQQkQCgC1A26flUNRY4DRROo2sxxmQDNuRq0lWAvx/t65SgfZ0SbP/jDJ+u2MfMdVGErz5Ak4qFeO7emtQvW9DbYRpzK+YA01T1sog8htPDdjvwF2CuqkZ5drKp6kkRGQJMB+KBFUDlmzmhiDwKPApQrly5NLkIY0zWYD10JsPUKJGf17vVZeVz7Xj+3hpERp+n6/vLeXnOFs5fjvV2eMZ4Osj/es8AyrhliVQ1WlUvu6uTgVB3uRkwTEQigbeBB0VkrHvMHFVtoqrNgB3A70nP5/beFQCikwalqhNVNUxVw4oWLZr6qzTGZBmW0JkMVzB3Dh5tVZkFT7bmgabl+WRFJHf9eymLtx/1dmjGJFgNVBWRiiKSA+gDzPbcQURKeqx2ArYBqGo/VS2nqhVwhl2nqupo95hi7s9gnJ68ye7xs4EB7nIPYJHa61iMMTfBEjrjNfmCAnmlcx1mPN6M3Dn8eeiT1Qyfto5jZy/f+GBj0pF7H9swYB5OovaVqm4RkVdEpJO72wh3+pENwAhgYAqqfldEtgLLgbGqmtBDNwUoLCK7gCeBP02TYowx1yPZ+UtgWFiYRkREeDsMA1yJjWfCz7t5b9EucuXw52/31qRnWBnsQT+T1kRkjaqGeTuO1LL2y5js53rtl/XQmUwhR4AfI9pVZe4TLalePB/PfLOR+yf9xt7j570dmjHGGJPpWUJnMpUqxfIS/mhTXutah80HT9P+naWMX7yLmLh4b4dmjDHGZFqW0JlMx89P6NekPAv+2pq21Yvx1rwd3PefX1h/4JS3QzPGGGMyJUvoTKZVPH8QEx4I5cMHQjl54Qpd31/Ok1+tZ9fRc94OzRhjjMlUbGJhk+ndXbsEzSoX5j8Ld/LZyn3MXHeQDnVLMuz2KtQokd/b4RljjDFeZz10xifkDwrkbx1q8cuzt/N468os3n6U9u8sY/DUCDZGnfJ2eMYYY4xXWQ+d8SlF8ubk2fY1eKxVJT5eHsnHy/cyf+sRWlcryoh2VQgtX8jbIRpjjDEZznrojE8qmDsHo+6sxvLRt/P03dXZdPA03T/4lb4TV7Ji93Gy8/yKxhhjsh9L6IxPyxcUyNC2Vfjl2bb8vUNNdh07x/2TfqPHhF9ZvOOoJXaGOXPmEB9v094YY7I2S+hMlpA7RwCDWlZi2TNteaVzbQ6fushDH6+m98SV/H7krLfDM140ffp0qlatyjPPPMP27du9HY4xxqQLS+hSIvYKHN8JJyPhzCE4fxwunoIrFyAuFqwXKNMICvTnwWYVWPJ0W17tUoffj5zl3neXMfbH7Vy4Euvt8IwXfP7556xbt47KlSszcOBAgBoi8qiI5PNyaMYYk2bsoYiUOH0A3rveqx8F/HOAf6D7yQEBOaF+f2j1FPj5Z1ioxpEjwI/+TctzT50SjP1xOxN+3s2cDYd46b5a3FW7hLfDMxksf/789OjRg4sXL/Lbb78FAl2Bp0VknKr+x9vxGWNMallClxJ5ikL3KRB3xf3EJFmO+XP56QOw5J+wdyl0mwgFSnv7KrKlwnlz8lbPEHo1KsvfZ27m0c/WcEfNYrx0X23KFsrt7fBMBpg9ezYff/wxu3bt4sEHHwTYpqr3iEhuYCtgCZ3xqpiYGKKiorh06ZK3QzGZRFBQEGXKlCEwMDDFx0h63jQuIu2BdwF/YLKqjk1mn17AGECBDap6v1v+JtABZ1h4PvCEqqqI9AWed/c/BPRX1eMiUgiYDlQAIoFeqnryevGFhYVpREREGlzpNayfBj/81emt6/IBVG+ffucyNxQTF88nyyP594LfiVdl+O1VGdyyEjkC7M6DrGzAgAE88sgjtGrVCgARWaOqYe5yO1Vd6NUAb1G6t18mw+zdu5d8+fJRuHBhRMTb4RgvU1Wio6M5e/YsFStWvGqbZ/uVVLr9TyYi/sB44B6gFtBXRGol2acq8BzQXFVrAyPd8tuA5kA9oA7QCGgtIgE4CWJbVa0HbASGudWNBhaqalVgobvuXfX7wmM/O71z03rDT89B7GVvR5VtBfr7MbhVJRY82Zo21Zx3xN7z7lJW7D7u7dBMOhozZgyNGzf2LBIRqQDgq8mcyVouXbpkyZxJJCIULlz4pnts07NrojGwS1X3qOoVIBzonGSfwcD4hJ40VT3qlisQBOQAcgKBwBFA3E8ecf7m58fppcOt+1N3+VOgSzpc080rUhUeWQCNH4OV78OUOyF6t7ejytZKFczFhAdC+XhgI2LilPsn/cbI8HUcO2vJdlbUs2dP/Pz+1NR97Y1YjLkWS+aMp1v5+5CeCV1p4IDHepRb5qkaUE1ElovISneIFlX9FVgMHHY/81R1m6rGAEOATTiJXC1giltXcVU97C7/ARRPh2u6NYFBcO+b0OdLOLUfPmwFG6Z7O6psr22NYvx3VCtG3F6FuZv+4PZ/LSF81X6buy6LiY2NJUeOHJ5FivNl0Rhjsgxv3zwUAFQF2gB9gUkiUlBEqgA1gTI4SeDtItJSRAJxEroGQCmcIdfnklaqzv/Iyf6v7E5XECEiEceOHUuHS7qOGh3g8V+gRD2Y+SjMHAKXz2VsDOYqQYH+PHlXdX4c2ZI6pQow+ttNDJu2jjOXYrwdmkkjRYsWZfbs2Z5FBQEbZzcGiI6Opn79+tSvX58SJUpQunTpxPUrV65c99iIiAhGjBhxw3PcdtttaRUuACNHjqR06dI2YXgS6ZnQHQTKeqyXccs8RQGzVTVGVfcCv+MkeF2Blap6TlXPAT8CzYD6AKq6203avgIS/qYcEZGSAO7PoyRDVSeqapiqhhUtWjQNLvMmFSgDA+ZA62dhwzSY2AYOb8z4OMxVKhfNyxeDmvBM++r8tPkPOo77hY1Rp7wdlkkDEyZM4J///CflypWjbNmyACWAx7wcljGZQuHChVm/fj3r16/n8ccfZ9SoUYnrOXLkIDb22vN3hoWFMW7cuBueY8WKFWkWb3x8PDNnzqRs2bL8/PPPaVZvUte77swqPRO61UBVEakoIjmAPsDsJPvMwumdQ0SK4AzB7gH24z4E4fbKtQa24SSEtUQkIRO70y3HrXuAuzwA+C4drilt+AdA2+dhwGy4cg4m3wG/TbQJir3Mz0/4S5sqTH+0KbFx8XT/YAUf/bLXhmB9XOXKlVm5ciVbt25l27ZtANtVdZe34zImsxo4cCCPP/44TZo04ZlnnmHVqlU0a9aMBg0acNttt7Fjxw4AlixZQseOHQHn4aOHH36YNm3aUKlSpasSvbx58ybu36ZNG3r06EGNGjXo169fYvs6d+5catSoQWhoKCNGjEisN6klS5ZQu3ZthgwZwrRp0xLLjxw5QteuXQkJCSEkJCQxiZw6dSr16tUjJCSEBx54IPH6ZsyYkWx8LVu2pFOnTtSq5TzD2aVLF0JDQ6lduzYTJ05MPOann36iYcOGhISE0K5dO+Lj46latSoJI3/x8fFUqVKFjBwJTNE8dCKSB7ioqvEiUg2oAfzo3tOWLFWNFZFhwDycaUs+UtUtIvIKEKGqs91td4nIViAOeFpVo0VkBnA7zr1yCvykqnPcWF4GlopIDLAPGOiecizwlYg84pb3uqnfhDdUbOUMwc4aAj8+DbvmQ4f/g4Jlb3ysSTdhFQox94mWPPX1Rl75fisrdkfzds96FMxtt135qh9++IEtW7YkPDVWUkReVNVXvB2XMUm9PGcLWw+dSdM6a5XKz0v31b6pY6KiolixYgX+/v6cOXOGZcuWERAQwIIFC3j++ef55ptv/nTM9u3bWbx4MWfPnqV69eoMGTLkT/OorVu3ji1btlCqVCmaN2/O8uXLCQsL47HHHmPp0qVUrFiRvn37XjOuadOm0bdvXzp37szzzz9PTEwMgYGBjBgxgtatWzNz5kzi4uI4d+4cW7Zs4dVXX2XFihUUKVKEEydO3PC6165dy+bNmxOnC/noo48oVKgQFy9epFGjRnTv3p34+HgGDx6cGO+JEyfw8/Ojf//+fPHFF4wcOZIFCxYQEhJCRo4EprSHbikQJCKlgf8CDwCf3OggVZ2rqtVUtbKqvuaWvegmc6jjSVWtpap1VTXcLY9T1cdUtaa77UmPOie45fVU9T5VjXbLo1W1napWVdU7VPXGf3KZQZ4icP9XcM+bEPkLvN/U6a2zewO8qmDuHEx6MJQXO9bi59+Pcu+7y1izzzf+SpmrPf7440yfPp3//Oc/Cb0BwUB5L4dlTKbWs2dP/P2dtxydPn2anj17UqdOHUaNGsWWLVuSPaZDhw7kzJmTIkWKUKxYMY4cOfKnfRo3bkyZMmXw8/Ojfv36REZGsn37dipVqpSYRF0robty5Qpz586lS5cu5M+fnyZNmjBv3jwAFi1axJAhQwDw9/enQIECLFq0iJ49e1KkSBEAChUqdMPrbty48VVzv40bN46QkBCaNm3KgQMH2LlzJytXrqRVq1aJ+yXU+/DDDzN16lTASQQfeuihG54vLaX0TRGiqhfc3q/3VfVNEVmfjnFlLyLQ5DGo1h6+H+n01m36Gjr9B4rV8HZ02ZaI8HCLioRVCGbYl+vo9eFK/npXNR5vVRk/P5tiwFesWLGCjRs3Uq9ePV566SXGjBmzHef2DmMynZvtSUsvefLkSVx+4YUXaNu2LTNnziQyMpI2bdoke0zOnDkTl/39/ZO9Dy0l+1zLvHnzOHXqFHXr1gXgwoUL5MqV65rDs9cSEBCQ+EBFfHz8VQ9/eF73kiVLWLBgAb/++iu5c+emTZs2150brmzZshQvXpxFixaxatUqvvjii5uKK7VS2kMnItIM6Af84JbZC0rTWnB56P8tdP0QonfChy1hyRsQe/0njUz6qlemIN+PaEH7OiV486cdDPh4FcfP2Zx1viIoKAiA3Llzc+jQIXBu4yjpzZiM8SWnT5+mdGln1rFPPvkkzeuvXr06e/bsITIyEoDp05Of1mvatGlMnjyZyMhIIiMj2bt3L/Pnz+fChQu0a9eODz74AIC4uDhOnz7N7bffztdff010dDRA4pBrhQoVWLNmDeC8GjAmJvm7x06fPk1wcDC5c+dm+/btrFy5EoCmTZuydOlS9u7de1W9AIMGDaJ///5X9XBmlJQmdCNxpgeZ6d4HVwlnnjiT1kQgpA8MXQ01Oznvg/2wFRxY7e3IsrX8QYG817cB/+xal1V7T3DPu8tYsctmvvAF9913H6dOneLpp5+mYcOGAHWBL70cljE+45lnnuG5556jQYMG6fL0Z65cuXj//fdp3749oaGh5MuXjwIFCly1z4ULF/jpp5/o0KFDYlmePHlo0aIFc+bM4d1332Xx4sXUrVuX0NBQtm7dSu3atfnb3/5G69atCQkJ4cknnbu3Bg8ezM8//0xISAi//vrrVb1yntq3b09sbCw1a9Zk9OjRNG3aFHCmQpo4cSLdunUjJCSE3r17Jx7TqVMnzp07l+HDrXAL73IVET8gr6qm7V2bXuAT70L8fR58/yScOegMy97+AuTM6+2osrVth88w7Mu17Dl+niGtKzPs9irkzpHSuxdMRoqPj2flypWJ82BdvnyZoKCg9arawMuhpZpPtF8mRbZt20bNmjW9HYZXnTt3jrx586KqDB06lKpVqzJq1Chvh3XTIiIiGDVqFMuWLUt1Xcn9vUj1u1xF5EsRye8+7boZ2CoiT6c6WnNj1e6GoSuh0SD47UPnoYmdC7wdVbZWs2R+Zg9rQY+GZXh/yW5uf/tnZq07SHy8TW+S2fj5+TF06NDEdff+nTivBWSMSdakSZOoX78+tWvX5vTp0zz2mO9NFTl27Fi6d+/O66+/7pXzp6iHTkTWq2p9EekHNMR58f0aVa2X3gGmJ5/7hrt/JcweAcd3QN1e0H4s5Cns7aiytYjIE7w8ZyubDp6mftmCvHhfLRqWC/Z2WMbDU089RbNmzejWrRsict1vuL7E59ovc03WQ2eSky49dECgO8FvF9w3O3CNV2uZdFSuKTy+zHnLxJaZ8F4YbAi3CYm9KKxCIb4b2py3e4Zw6NRFur2/gpHh6zh8+qK3QzOuDz/8kJ49e5IzZ07y588P0EBEfP6WEWOM8ZTShO5DIBLIgzOpb3nAGkRvCMjpvGXisaVQuDLMfAw+7wYnI70dWbbl5yf0CC3D4qfaMLRtZeZu/oO2by/hnQW/c/GKje5529mzZxOnJjhz5gzAOlXN7+24jDEmLaXoTm5VHQd4vrBtn4i0TZ+QTIoUrwUPz4PVU2DhyzC+qZPoNf2L82oxk+Hy5Azg6btr0KdROcb+uJ13Fuxk+uoDjL6nBp1CSiFic9d5w9KlS5MW5RWRVqr6pw3GGOOrUvrqrwLAS0Art+hn4BXgdDrFZVLCzx+aPAo17oUfnoL5L8DmGc6ExCVDMjaW+Hg4dwTy2/ReZQvlZny/hjy4J5pXvt/KE+Hr+XRFJC/eV5v6ZQt6O7xs56233kpcdicFrQKMwXm9oDHGZAkpHXL9CDiL837UXjjDrR+nV1DmJhUoA32nQc9P4MxhmNgW/vsCXLmQ/ue+dBp+fR/eC4X/qwFrPk3/c/qIJpUKM3tYC97sXo/9Jy7SZfxynvp6A2cvXfMVyCYdzJkzJ/Ezf/58gC3ASS+HZUym0bZt28RXaCV45513El+llZw2bdqQ8FDOvffey6lTp/60z5gxY3j77beve+5Zs2axdevWxPUXX3yRBQvSbiaHkSNHUrp06cQ3Q2RlKU3oKqvqS6q6x/28DFRKz8DMTRKB2l1h2Cpo0A9WjIMPmsHudJr/+chW+H4U/KsmzHsOcheB8s1hzhOw+c8vbc6u/P2EXo3KsuTpNjzeujIz1x2k03vL0/zl2+amxAD2SKExrr59+xIeHn5VWXh4+DXfqZrU3LlzKViw4C2dO2lC98orr3DHHXfcUl1JxcfHM3PmTMqWLcvPP/+cJnUmJz0mW74VKU3oLopIi4QVEWkO2GN8mVGuYGfIdcD3IP7wWReY+ThcSIMXy8fFwtbZ8ElHJ1lc9wXU7gKPLoFB86HfDCjXDL591JkQ2STKmzOA0ffU4MtBTTh/OZau7y9n+ur93OzE3ubmDR8+nBEjRjBixAiGDRsGUB1Y6+WwjMk0evTowQ8//JD4TtPIyEgOHTpEy5YtGTJkCGFhYdSuXZuXXnop2eMrVKjA8ePOm3Nee+01qlWrRosWLdixY0fiPpMmTaJRo0aEhITQvXt3Lly4wIoVK5g9ezZPP/009evXZ/fu3QwcOJAZM2YAsHDhQho0aEDdunV5+OGHuXz5cuL5XnrpJRo2bEjdunXZvn17snEtWbKE2rVrM2TIEKZNm5ZYfuTIEbp27UpISAghISGsWLECgKlTp1KvXj1CQkJ44IEHAK6KByBv3ryJdbds2ZJOnTpRq1YtALp06UJoaCi1a9dm4sSJicf89NNPNGzYkJCQENq1a0d8fDxVq1bl2LFjgJN4VqlSJXH9VqX07vnHganuvXTgDFcMSNWZTfqq2BKGrIClb8Hyd2Dnf6HFKChSHQqUdoZpgwrcsBoAzkfD2k9g9UdwJgoKlIU7xkCDB6+eBy9Hbrg/HD69D756EPp/AxVaXKvWbKlJpcLMfaIlI8PX8+w3m/htzwle7VrH3jSRjsLC/jdlU0BAAOPHj49S1f5eDMmYa/txNPyxKW3rLFEX7hl7zc2FChWicePG/Pjjj3Tu3Jnw8HB69eqFiPDaa69RqFAh4uLiaNeuHRs3bqReveSnoF2zZg3h4eGsX7+e2NhYGjZsSGhoKADdunVj8ODBAPz9739nypQpDB8+nE6dOtGxY0d69OhxVV2XLl1i4MCBLFy4kGrVqvHggw/ywQcfMHLkSACKFCnC2rVref/993n77beZPHnyn+KZNm0affv2pXPnzjz//PPExMQQGBjIiBEjaN26NTNnziQuLo5z586xZcsWXn31VVasWEGRIkWuej/rtaxdu5bNmzdTsWJFAD766CMKFSrExYsXadSoEd27dyc+Pp7BgwezdOlSKlasyIkTJ/Dz86N///588cUXjBw5kgULFhASEkLRokVveM7rSelTrhuAEBHJ766fEZGRwMZUnd2kr8AgaPcC1OnmTEj8379fvT1HPiexS0jw8nsul4ZLp2DVZGcINe4yVGwF97wB1dpf+0naoALQfyZ8fA982RsGzIbSoel+qb6kSN6cfPpwY/6zaCfvLtzJpoOneb9fQ6oWz+ft0LKkHj16EBQUlPii7P79+58XkdyqmgE3mRrjGxKGXRMSuilTpgDw1VdfMXHiRGJjYzl8+DBbt269ZkK3bNkyunbtSu7cuQHnvaYJNm/ezN///ndOnTrFuXPnuPvuu68bz44dO6hYsSLVqlUDYMCAAYwfPz4xoevWrRsAoaGhfPvtt386/sqVK8ydO5f/+7//I1++fDRp0oR58+bRsWNHFi1axNSpUwHw9/enQIECTJ06lZ49e1KkSBHASXJvpHHjxonJHMC4ceOYOXMmAAcOHGDnzp0cO3aMVq1aJe6XUO/DDz9M586dGTlyJB999FGavPv1proFkry/9UngnVRHYNJf8dowaAGcPQynD8LpA867YU9H/e9zaD1cSOZl84F5oEF/aPwoFKuRsvPlKQwPzoKP2sPn3WHgXGeaFZPI308YeUc1wsoX4onwdXR6bzn/7FaHrg3KeDu0LKddu3YsWLAgcagE51aTBcBt3ovKmGu4Tk9aeurcuTOjRo1i7dq1XLhwgdDQUPbu3cvbb7/N6tWrCQ4OZuDAgQlPit+0gQMHMmvWLEJCQvjkk09YsmRJquJ1X+OHv79/svewzZs3j1OnTlG3bl0ALly4QK5cuejYseNNnScgICDxgYqE+SwT5MmTJ3F5yZIlLFiwgF9//ZXcuXPTpk2b6/6uypYtS/HixVm0aBGrVq3iiy++uKm4kpPSe+iSY5Nq+RIRyF8KyjZyeuxuG+70tvX5Ah77GZ7ZDX/7A4avhQe/g87vQ6f34K/boOP/pTyZS5C/lFOPf07nPr4Te9Llsnxdi6pFmPtES+qWKcCo6Rt47tuNXIqxyYjT0qVLlzyTOYB4IPeNjhOR9iKyQ0R2icjoZLYPFJFjIrLe/QxKsj2/iESJyHseZX1FZJOIbBSRn0SkiFs+RkQOetR17y1fsDG3IG/evLRt25aHH3448WGIM2fOkCdPHgoUKMCRI0f48ccfr1tHq1atmDVrFhcvXuTs2bPMmTMncdvZs2cpWbIkMTExVyUv+fLl4+zZs3+qq3r16kRGRrJr1y4APvvsM1q3bp3i65k2bRqTJ08mMjKSyMhI9u7dy/z587lw4QLt2rXjgw8+ACAuLo7Tp09z++238/XXXxMdHQ2QOORaoUIF1qxZA8Ds2bOJiUl+loLTp08THBxM7ty52b59OytXrgSgadOmLF26lL17915VL8CgQYPo378/PXv2TBxBSI3UJHR2N3dWE5jLeftEpTbOk7INH0j5fXbJKVTR6amLi4GpnZ3eQfMnxfMH8eWgJvylTWWmrTpA1/dXsPf4eW+HlWXkyZOHtWuvegYiNzd4qEtE/IHxwD1ALaCviCTXzTxdVeu7n6Q38fwDSJy8WEQCgHeBtu57sDcCwzz2/7dHXXNTeHnGpJm+ffuyYcOGxIQuJCSEBg0aUKNGDe6//36aN29+3eMbNmxI7969CQkJ4Z577qFRo0aJ2/7xj3/QpEkTmjdvTo0a/+sg6NOnD2+99RYNGjRg9+7dieVBQUF8/PHH9OzZk7p16+Ln58fjjz+eouu4cOECP/30Ex06dEgsy5MnDy1atGDOnDm8++67LF68mLp16xIaGsrWrVupXbs2f/vb32jdujUhISE8+eSTAAwePJiff/6ZkJAQfv3116t65Ty1b9+e2NhYatasyejRo2natCkARYsWZeLEiXTr1o2QkBB69+6deEynTp04d+5cmgy3Asj1nrITkbMkn7gJkEtVffpObnu5dQY5uBY+7eRMOvzQj5CniLcjyrQWbz/KqK/WExunvNG9Hh3q2UTNqbV69Wr69OlDqVKlUFWWL19+GWiuqmuudYyINAPGqOrd7vpzAKr6usc+A4EwVR2WzPGhwNPATwn7uO/DPgSEAfuBD4C1qjpRRMYA51T1+pN2ebD2K+tI7iXsJuuLiIhg1KhRLFu2LNntyf29EJE1qhqW3P7X7aFT1Xyqmj+ZTz5fT+ZMBirdEO6fDqf2w2dd4eIpb0eUabWtUYwfRrSkavG8DP1yLS/M2sypC1dufKC5pkaNGrF9+3Y++OADJkyYALDlesmcqzRwwGM9yi1Lqrs7fDpDRMoCiIgf8C/gKc8dVTUGGAJswknsagFTPHYZ5tb1kYgE38QlGmN8zNixY+nevTuvv/76jXdOodQMuRqTchWaQ+/P4eg25+nXKzakeC2lC+Zi+qPNeKRFRT5buY/mYxfx+o/bOHb2srdD80njx4/n/Pnz1KlThzp16gD4ichf0qDqOUAFd/h0PpDwmpS/AHNVNcpzZ7eHbgjQACiFM+T6nLv5A6AyUB84jJMQ/omIPCoiESISkdo5q4wx3jN69Gj27dtHixZpN7WXJXQm41S9E7pPgqhVML0/xFqCci05Avx4oWMtfhrZknY1izNp6R5avLGIMbO3cOiUzel9MyZNmpR0Fvs4YPANDjsIlPVYL+OWJVLVaFVN+Es8GUiYn6cZTm9bJPA28KCIjMVJ1lDV3erc6/IV7pO2qnpEVeNUNR6YBDROLihVnaiqYaoalto5q0zmYpOMG0+38vfBEjqTsWp3hfvGwe5F8M0jltTdQI0S+RnXtwEL/9qGzvVL8fnKfbR+azGjv9nIvmjr5UyJuLi45BrHHDc4bDVQVUQqikgOoA8w23MHEfG8wbETsA1AVfupajlVrYAz7DpVVUfjJIS1RCQhE7sz4ZgkdXUFNqfw8kwWEBQURHR0tCV1BnCSuejoaIKCgm7qOLsPzmS8hg/A5bPOO2D/Ewqtn4GQ+689WbGhYpE8vNkjhBHtqjJx6R7CVx/gq4gDdK5fmr+0qWyTEl9H+/bt6d27N4899lhCUSXgo+sdo6qxIjIMmAf4Ax+p6hYReQWIUNXZwAgR6QTEAieAgTeo85CIvAwsFZEYYJ/HMW+KSH2ch9AigceSq8NkTWXKlCEqKirVr34yWUdQUBBlytzcvKTXfco1q7OnxLxs92JY9A84uAYKVYI2z0Od7uBnHcc3cvTMJSYt28MXv+3nYkwc7WuXYGjbKtQpnYppZrKo+Ph4Jk6cyMKFCwGYMWPGIWCWqg71bmSpY+2XMdnPLT/laky6qtwWBi2EPtMgMDd8OwgmNIdtcyAbf9FIiWL5g/hbh1r88uztDGtbhV92Hqfjf37h4U9Wc9DusbuKn58fTZo0oUKFCqxatQogH+5QpzHGZBWW0BnvEoEa98Jjy6DHRxB3xXlgYlJb2LXAErsbKJQnB3+9qzrLn7udp++uzuq9J+j0n1/4bU+0t0Pzut9//52XX36ZGjVqMHz4cMqVK5e4SVXfu96xxhjjayyhM5mDn58z3PqX36DzeDgf7bwH9uN7IXK5t6PL9PIHBTK0bRVmDWtOgdyB9Jv8G1N/jczWN1nXqFGDRYsW8f333/PLL78wfPjwNHm9jjHGZEaW0JnMxT8AGvSH4Wvg3redd8B+cq8zIfHBG80FayoXzcusoc1pVa0oL363hdHfbOJybPZ8N+y3335LyZIladu2LYMHD2bhwoXZOsE1xmRtltCZzCkgBzQeDCPWwV2vwqH1MOl2+OGvNtXJDeQPCmTSg2EMa1uF6REH6DtxJUfPXPJ2WBmuS5cuhIeHs337dtq2bcs777zD0aNHAcqJyF3ejs8YY9KSPeVqT4n5hstnYclY+PU9KB0KPT+FgmVvfFw2N3fTYf761Qby5wpgQv9QGpTL3m+UOnnyJIUKFdoH7FbVdt6OJzWs/TIm+7GnXI3vy5kP7n4Nen0Gx36HD1vBroXejirTu7duSb79y23kCPCj94cr+TriwI0PysKCg4MBjvt6MmeMMUlZQmd8S61O8OgSyFfCeWhiyRsQH+/tqDK1miXzM3toCxpVDObpGRsZM3sLMXH2OzPGmKzEEjrje4pUgUELoF4vWPJP+LIXXDjh7agyteA8Ofj0ocY80qIin6yI5MEpqzhx/oq3wzLGGJNGLKEzvilHHuj6IXT4P9j7M3zYGg6u9XZUmVqAvx8vdKzFv3qGsGb/Se77zy9sOXTa22EZY4xJA5bQGd8lAo0egYd/AhQ+uhsiPrLJiG+ge2gZZjzejHhVun+wgi9+20d8vP3OjDHGl1lCZ3xf6VB4bClUaAnfj4JZQ+DKBW9HlanVK1OQ2cNaEFo+mL/N3Mz9k1eyL/q8t8MyxhhziyyhM1lD7kLQ72to8xxsCIcpd0L0bm9HlakVzZeTzx9pwthuddly8Ax3v7OUycv2EGe9dcYY43MsoTNZh58/tBkN/WfAmYMwsQ2snmITEV+HiNCncTn++2Qrmlcuwqs/bKP7Byv4/chZb4dmjDHmJlhCZ7KeKnc4Q7DFasEPT8I79WD5OGdyYpOskgVyMXlAGO/2qc++6PN0HPcL/1m406Y3McYYH2EJncmaCpZzHpZ4YBYUrQ7zX4B/14ZFr8L5496OLlMSETrXL838J1tzV+3i/Gv+73R6bzmbD9qTsMYYk9lZQmeyLhGo3BYGzIZBi5yHJpa+Bf+uA3OfgVPZ+60J11Ikb07eu78hEx8IJfrcZTqPX84bP23nUkyct0MzxhhzDema0IlIexHZISK7RGT0NfbpJSJbRWSLiHzpUf6mW7ZNRMaJI5+IrPf4HBeRd9z9B4rIMY9tg9Lz2oyPKRMKfb6AoaugTjeImALj6sPMx+Hodm9HlyndVbsE80e1pnvD0nywZDf3jltGRKRN4GyMMZlRuiV0IuIPjAfuAWoBfUWkVpJ9qgLPAc1VtTYw0i2/DWgO1APqAI2A1qp6VlXrJ3yAfcC3HlVO99g+Ob2uzfiwotWhy/vwxAZoNBi2fgfvN4HwfhBlLzpPqkDuQN7sEcLUhxtzOSaenh/+ynPfbiL6nD1oYowxmUl69tA1Bnap6h5VvQKEA52T7DMYGK+qJwFU9ahbrkAQkAPICQQCRzwPFJFqQDFgWbpdgcm6CpSBe8bCyM3Q+lmI/AUmt4PZw21i4mS0qlaU/45qxUO3VeSriAO0eXsJk5ft4UqsPTRhjDGZQXomdKUBz5uUotwyT9WAaiKyXERWikh7AFX9FVgMHHY/81R1W5Jj++D0yHn+79tdRDaKyAwRKZtcUCLyqIhEiEjEsWPHbv3qTNaQpzC0fR5GbYGmQ2HtVGc41vxJnpwBvHhfLeaNbEmDcsG8+sM22r+zlMXbj974YGOMMenK2w9FBABVgTZAX2CSiBQUkSpATaAMThJ4u4i0THJsH2Cax/ocoIKq1gPmA58md0JVnaiqYaoaVrRo0TS9GOPDcuaFu16FqnfBT8/BwTXejijTqlIsH58+1IiPBoYB8NAnqxnw0Sp2HbVpYYwxxlvSM6E7CHj2kpVxyzxFAbNVNUZV9wK/4yR4XYGVqnpOVc8BPwLNEg4SkRAgQFUT/9dV1WhVTbixZzIQmtYXZLI4Pz/o+iHkLQFfDYQL9gDAtYgIt9cozk8jW/H3DjVZu+8kd7+zjJfnbOH0hRhvh2eMMdlOeiZ0q4GqIlJRRHLg9KjNTrLPLJzeOUSkCM4Q7B5gP9BaRAJEJBBoDXgOufbl6t45RKSkx2qnJPsbkzK5C0GvT+DsYecJ2Hi7R+x6cgT4MahlJRY/3YZeYWX5ZEUkbd5ezGcr9xFrkxIbY0yGSbeETlVjgWHAPJzk6itV3SIir4hIJ3e3eUC0iGzFuWfuaVWNBmYAu4FNwAZgg6rO8ai+F0kSOmCEO83JBmAEMDCdLs1kdaVDof3rsHMeLP+3d2OJueTd86dQkbw5eb1bXb4f3oJqxfPxwqzNdBj3C8t32STOxhiTEUSz8RN9YWFhGhFhU1WYZKjCN4Ngy7fw4HdQsVXGx7ByAiwYA8NWQ8Fkn/HJlFSVnzb/wWtztxF18iL9m5bjH53rICLeDg0AEVmjqmHejiO1rP0yJvu5Xvvl7YcijMmcROC+d6FwVZjxMJw5nLHnP7LVeV1Z7EXY9HXGnjuVRIR76pZkwZOtebh5RT5fuZ9/zt1Gdv7yaIwx6c0SOmOuJWde6DUVrpx3krq42Iw5b+xl+PZRCCoAxevCxq98cm68oEB/XuhYkweblWfSsr28v2S3t0MyxpgsyxI6Y66nWA24bxzsXwGLXsmYcy5+DY5sgk7vQdhAOLYNjmzOmHOnMRFhzH216Vy/FG/N28HnK/d5OyRjjMmSLKEz5kbq9YSwR2D5u7D9h/Q9V+RyWD4OQgdC9fZQuxv4BcDG6el73nTk5ye83TOE22sU44XvNjN7wyFvh2SMMVmOJXTGpET716FUA5g5BE7sTZ9zXDrjTJUSXAHues0py13Imex40wyIj0uf82aAQH8/3u/XkEYVCvHk9PX2dgljjEljltAZkxIBOaHnp87DEl89mD7Tifw0Gs5EQbeJzv17Cer2dObFi/Tt1xYHBfozeUAY1UvkY8gXa1i11yZuNsaYtGIJnTEpFVzeeZPEHxvhp2fTtu6ts2H9F9DyKSjb+Opt1e+BHPlgo2897Zqc/EGBfPpwY0oVyMUjn6xm88HT3g7JGGOyBEvojLkZ1dtDiydhzSewPunc1rfo7B8w5wkoWR9aP/Pn7YG5oFZn2PodxFxMm3N6UZG8OflsUBPyBQUw4KNV7Dl2ztshGWOMz7OEzpib1fZvUKElfD8KjmxJXV2q8N0wiLkA3SaBf2Dy+9XrCVfOwo4fU3e+TKJ0wVx8NqgJCjwwZRWHT/t+omqMMd5kCZ0xN8s/ALpPgaD88FlX2PzNrc8TF/ER7JoPd/4Dila79n4VWkK+ks6cdFlE5aJ5mfpwY05fjKH/5N84cf6Kt0MyxhifZQmdMbciX3Ho/62TZM14GD7rAsd33Vwdx3fBf/8OlW+HRoOuv6+fP9Tt4SR/56NvOezMpk7pAkweEEbUyYsM/HgVZy/FeDskY4zxSZbQGXOrStSBwYvg3rfh4Dr4oBksejVl97nFxcC3g8E/B3R+H/xS8E+xbi+Ij4WtM1MfeybStFJh3u/XkC2HzjB4agSXYnx3ehZjjPEWS+iMSQ0/f2g8GIZHOJMAL30LxjeB3+dd/7hl/4JDa+G+dyB/yZSdq0RdKFozSw27JmhXszj/6hnCb3tPMHhqBKcu2PCrMcbcDEvojEkLeYtBtw9hwPcQEARf9oLwfnDqwJ/3jVoDP78J9XpD7a4pP4cI1OsFB35Lv8mNvahLg9K80a0eK/dE02HcL2yMOuXVeESkvYjsEJFdIjI6me0DReSYiKx3P4OSbM8vIlEi8p5HWV8R2SQiG0XkJxEp4pYXEpH5IrLT/Rmc/ldojMlKLKEzJi1VbAmP/wJ3vAy7F8H4xvDLvyHW7XG6ct4Zas1XEu558+brr9vT+blpRtrFnIn0alSWrx5rBkCPD37ls5X70Ft94CQVRMQfGA/cA9QC+opIrWR2na6q9d3P5CTb/gEs9agzAHgXaKuq9YCNwDB382hgoapWBRa668YYk2KW0BmT1gJyQIuRMHSV88DDgjEwoQXsXQb/fQFO7IGuEyBXwZuvu2BZKN/ceberFxKdjNCgXDDfD2/BbVUK88KszYyavp7zl2MzOozGwC5V3aOqV4BwoHNKDxaRUKA48F/PYveTR0QEyA8kvNi2M/Cpu/wp0CVV0Rtjsh1L6IxJLwXLQp8v4P6vIPYSfNoRIqZAs6FOT96tqtcLonfCoXVpF2smE5wnBx8NaMRf76zGdxsO0WX8cnYdPZuRIZQGPMfLo9yypLq7w6czRKQsgIj4Af8CnvLcUVVjgCHAJpxErhYwxd1cXFUPu8t/4CSDxhiTYpbQGZPeqt0NQ3+D1s86b3y4/YXU1Vers/N07CbffxXY9fj5CcPbVeWzh5tw4vwVOr23nNkbDt34wIwzB6jgDp/O5389bH8B5qpqlOfOIhKIk9A1AErhDLk+l7RSdcaYk+1+FZFHRSRCRCKOHTuWZhdijPF9ltAZkxECc0Hb56HXVAgMSl1duYKh6l3OfXRxGT4UmeFaVC3CDyNaUqtkfkZMW8eL323mcmy6T21yECjrsV7GLUukqtGqetldnQyEusvNgGEiEgm8DTwoImOB+u5xu92k7SvgNveYIyJSEsD9eTS5oFR1oqqGqWpY0aJFU3eFxpgsxRI6Y3xRvd5w/ijsXeLtSDJEiQJBTHu0KYNaVGTqr/vo9eFKok5eSM9TrgaqikhFEckB9AFme+6QkIC5OgHbAFS1n6qWU9UKOMOuU1V1NE5CWEtEEjKxOxOOcese4C4PAL5L+0syxmRlltAZ44uq3gVBBbLknHTXEujvx9871mJC/4bsOXqOjv/5hcU7ku3ISjVVjcV5AnUeTtL1lapuEZFXRKSTu9sIEdkiIhuAEcDAG9R5CHgZWCoiG3F67P7pbh4L3CkiO4E73HVjjEkx8caUAJlFWFiYRkREeDsMY27N7BHOsOvTOyFHHm9Hk6H2Hj/PkM/XsP2Pswy/vQoj76iGv5+k6FgRWaOqYekcYrqz9suY7Od67Zf10Bnjq+r1gpjzsH2utyPJcBWL5GHW0Ob0CivD3E2H7XVhxphsL8DbARhjblG52yB/GWdOuno9vR1NhgsK9OfNHiGcvhhDnpzWlBljsjfroTPGV/n5OYnc7kVwLvtOYVEgV6C3QzDGGK+zhM4YX1a3F2gcbPnW25EYY4zxIkvojPFlxWtB8brOsKsxxphsyxI6Y3xdvV5wcA1E7/Z2JMYYY7zEEjpjfF3dHoBkqznpjDHGXM0SOmN8Xf5SULGlM+yajeeVNMaY7MwSOmOygnq94eReiLKJZo0xJjuyhM6YrKDmfRAQBJts2NUYY7IjS+iMyQqCCkC19rD5Gzi1H+JivR2RMcaYDGTTqxuTVYT0ha2z4J26IH6QrxQUKJPkU9b5WbCskwQaY4zJEiyhMyarqHY3DJgDJ/bA6aj/fQ5GwNbvID7m6v1z5oeC5eHu16BSa+/EbIwxJk1YQmdMViECFVs5n6Ti4+H8UTfJO+D+PAg7/wvh/eChuVCyXsbHbIwxJk1YQmdMduDnB/lKOJ8yYf8rb/4ETL4DvugBj8yH4PLei9EYY8wts4cijMnO8peE/t9A7CUnqbtwwtsRGWOMuQWW0BmT3RWrAX3D4eQ+mNYXYi56OyJjjDE3yRI6YwyUvw26TYQDv8E3gyA+ztsRGWOMuQmW0BljHLW7QPuxsP17+PFZe42YMcb4kHRN6ESkvYjsEJFdIjL6Gvv0EpGtIrJFRL70KH/TLdsmIuPEkU9E1nt8jovIO+7+OUVkunuu30SkQnpemzFZUtPH4bbhsHoSLH/H29EYY4xJoXR7ylVE/IHxwJ1AFLBaRGar6laPfaoCzwHNVfWkiBRzy28DmgMJ8yj8ArRW1SVAfY/j1wDfuquPACdVtYqI9AHeAHqn1/UZk2Xd8QqcOQwLxjiTE4fYPyNjjMns0rOHrjGwS1X3qOoVIBzonGSfwcB4VT0JoKpH3XIFgoAcQE4gEDjieaCIVAOKAcvcos7Ap+7yDKCdiEiaXpEx2YGfH3R5Hyq0hO/+ArsXezsiY4wxN5CeCV1p4IDHepRb5qkaUE1ElovIShFpD6CqvwKLgcPuZ56qbktybB9gumrijT6J51PVWOA0UDgNr8eY7CMgJ/T5AopUh+kPwOGN3o7IGGPMdXj7oYgAoCrQBugLTBKRgiJSBagJlMFJ1G4XkZZJju0DTLvZE4rIoyISISIRx44dS1XwxmRpQQWg/wzn5xc94NR+b0dkjDHmGtIzoTsIlPVYL+OWeYoCZqtqjKruBX7HSfC6AitV9ZyqngN+BJolHCQiIUCAqq5J7nwiEgAUAKKTBqWqE1U1TFXDihYtmtprNCZry1/KSepiL8Hn3W3iYWOMyaTSM6FbDVQVkYoikgOnR212kn1m4fTOISJFcIZg9wD7gdYiEiAigUBrwHPItS9/7p2bDQxwl3sAizyGY40xt6pYTegzDU5G2sTDxhiTSaVbQufexzYMmIeTjH2lqltE5BUR6eTuNg+IFpGtOPfMPa2q0TgPNewGNgEbgA2qOsej+l78OaGbAhQWkV3Ak0Cy06QYY25Bheb/m3j4i55w8ZS3IzLGGONBsnMnVlhYmEZERHg7DGN8x4Zw+G4oFK4K/b6GgmVvfEwmIyJrVDXM23GklrVfxmQ/12u/vP1QhDHGl4T0gf7fwplDMPkOOLzB2xEZY4zBEjpjzM2q1BoemQd+AfDRPbBzvrcjMsaYbM8SOmPMzStWEwYtgMKV4cveEPGxtyMyxphszRI6Y8ytyV8SHpoLldvC9yNhwcsQH+/tqIwxJluyhM4Yc+ty5oO+06HhAPjl/+DbwRB72dtRGWNMthPg7QCMMT7OPwDuexeCy8PCV+DsH9Dnc8gV7O3IjDEm27AeOmNM6olAy79Ct8kQtQqm3OVMRGyMMSZDWEJnjEk79XrCAzPh3BFnWpODa70dkTHGZAuW0Blj0laFFvDIfAjIBZ90gK3feTsiY4zJ8iyhM8akvaLVnWlNitaArx6E74bB5bPejsoYY7IsS+iMMekjX3F4eB60GAXrPocJLeDAKm9HlWIi0l5EdojILhH507uhRWSgiBwTkfXuZ1CS7flFJEpE3nPX83nsu15EjovIOympyxhjbsQSOmNM+gnIAXeMceari4+Hj+6GRa9CXIy3I7suEfEHxgP3ALWAviJSK5ldp6tqffczOcm2fwBLE1ZU9azHvvWBfcC3KazLGGOuyxI6Y0z6K38bDFkO9frA0rdgyp1wfKe3o7qexsAuVd2jqleAcKBzSg8WkVCgOPDfa2yvBhQDlqVBrMYYYwmdMSaDBOWHrh9Ar6nOlCYTWsKqSaDq7ciSUxo44LEe5ZYl1V1ENorIDBEpCyAifsC/gKeuU38fnB45z4v/U13GGJNSltAZYzJWrc4w5Fen127uU/BFTzh7xNtR3Yo5QAVVrQfMBz51y/8CzFXVqOsc2weYloK6riIij4pIhIhEHDt2LNUXYIzJOiyhM8ZkvPwlof83cM9bELkM3m8K2+Z4OypPBwHPXrIyblkiVY1W1YT3nE0GQt3lZsAwEYkE3gYeFJGxCceJSAgQoKprUlDXVVR1oqqGqWpY0aJFb/nijDFZjyV0xhjvEIEmj8JjS6FAGZjeH2YNzSzTm6wGqopIRRHJgdOjNttzBxEp6bHaCdgGoKr9VLWcqlbAGXadqqqeT8n25ereuWvWZYwxKWXvcjXGeFfR6jBoISx5HZa/A1GrYcBsyFfCayGpaqyIDAPmAf7AR6q6RUReASJUdTYwQkQ6AbHACWBgCqvvBdybpOxW6zLGGABEM+cNyRkiLCxMIyIivB2GMSbBnp9hWl9nDrsBc5yeuzQmImtUNSzNK85g1n4Zk/1cr/2yIVdjTOZRqbXzLtjzx+Hje5ynYY0xxtyQJXTGmMylXBN48Du4dAY+vheid3s7ImOMyfQsoTPGZD6lG8LA7yH2ktNTd3S7tyMyxphMzRI6Y0zmVKIuDJzrLH/SAf7Y7N14jDEmE7OEzhiTeRWr4SR1/jng045waJ23IzLGmEzJEjpjTOZWpAo8NBdy5oNPO8OB1d6OyOecvhBDdp7RwJjswBI6Y0zmV6ii01OXpzB81gUil3s7Ip/y2OcRtHhjMS99t5llO49xJTbe2yEZY9KYJXTGGN9QsKyT1OUvBZ93h92LvR2Rz+gRWpZapfIzPeIAD0xZReg/5jP0y7XMWneQ0xdivB2eMSYN2JsijDG+I39JJ6mb2hm+7A29P4dqd3k7qkyvR2gZeoSW4eKVOJbvOs6CbUdYsO0oP2w8jL+f0LhCIe6oVZw7ahajfOE83g7XGHML7E0RNtO6Mb7nwgln6PXIVuj1KdTokOJD7U0Rjvh4ZUPUKSe523qUHUecd+hWK56XO2oWJ6RsQfxE0ipcY8w1hJQtQLF8QSna93rtl/XQGWN8T+5C8OBsZ+h11l9g5EYIKuDtqHyKn5/QoFwwDcoF8/TdNdgffYH5246wYOsRPly6h7j47Ptl35iMNGVAGO1qpiyhux5L6IwxvilXQec1YdE7LZlLA+UK5+aRFhV5pEVFTl+I4cDJC94OyZhsoVzh3GlSjyV0xhjfFZQfSod6O4osp0DuQArktiTZGF9iT7kaY4wxxvg4S+iMMcYYY3ycJXTGGGOMMT7OEjpjjDHGGB9nCZ0xxhhjjI+zhM4YY4wxxsdZQmeMMcYY4+MsoTPGGGOM8XGW0BljjDHG+DhL6IwxxhhjfJyoZt8XMIvIMWDfTRxSBDieTuFkRtntesGuOTsor6pFvR1Ealn7lSLZ7Zqz2/VC9rvma7Zf2Tqhu1kiEqGqYd6OI6Nkt+sFu2aTdWXHP+fsds3Z7Xohe17ztdiQqzHGGGOMj7OEzhhjjDHGx1lCd3MmejuADJbdrhfsmk3WlR3/nLPbNWe364Xsec3JsnvojDHGGGN8nPXQGWOMMcb4OEvoUkBE2ovIDhHZJSKjvR1PRhCRSBHZJCLrRSTC2/GkBxH5SESOishmj7JCIjJfRHa6P4O9GWNausb1jhGRg+6f83oRudebMZq0Z+2XtV9ZhbVh12cJ3Q2IiD8wHrgHqAX0FZFa3o0qw7RV1fpZ+JHwT4D2ScpGAwtVtSqw0F3PKj7hz9cL8G/3z7m+qs7N4JhMOrL2y9qvjA4qnX2CtWHXZAndjTUGdqnqHlW9AoQDnb0ck0kDqroUOJGkuDPwqbv8KdAlI2NKT9e4XpO1WfuVRWW39gusDbsRS+hurDRwwGM9yi3L6hT4r4isEZFHvR1MBiquqofd5T+A4t4MJoMME5GN7nBGlhqiMdZ+WfuVLVgbhiV05tpaqGpDnKGaoSLSytsBZTR1HgHP6o+BfwBUBuoDh4F/eTUaY9KGtV/Zo/0Ca8MSWUJ3YweBsh7rZdyyLE1VD7o/jwIzcYZusoMjIlISwP151MvxpCtVPaKqcaoaD0wi+/w5ZxfWfln7laVZG/Y/ltDd2GqgqohUFJEcQB9gtpdjSlcikkdE8iUsA3cBm69/VJYxGxjgLg8AvvNiLOkuofF3dSX7/DlnF9Z+WfuVpVkb9j8B3g4gs1PVWBEZBswD/IGPVHWLl8NKb8WBmSICzt+RL1X1J++GlPZEZBrQBigiIlHAS8BY4CsReQTYB/TyXoRp6xrX20ZE6uMMzUQCj3krPpP2rP2y9st7EaY9a8Ouz94UYYwxxhjj42zI1RhjjDHGx1lCZ4wxxhjj4yyhM8YYY4zxcZbQGWOMMcb4OEvojDHGGGN8nCV0xqeJSJyIrPf4pNnLqEWkgohk2zmNjDHpy9ovk5ZsHjrj6y6qan1vB2GMMbfA2i+TZqyHzmRJIhIpIm+KyCYRWSUiVdzyCiKyyH2R80IRKeeWFxeRmSKywf3c5lblLyKTRGSLiPxXRHJ57aKMMdmCtV/mVlhCZ3xdriRDFr09tp1W1brAe8A7btl/gE9VtR7wBTDOLR8H/KyqIUBDIGE2/arAeFWtDZwCuqfr1RhjshNrv0yasTdFGJ8mIudUNW8y5ZHA7aq6R0QCgT9UtbCIHAdKqmqMW35YVYuIyDGgjKpe9qijAjBfVau6688Cgar6agZcmjEmi7P2y6Ql66EzWZleY/lmXPZYjsPuOzXGZAxrv8xNsYTOZGW9PX7+6i6vAPq4y/2AZe7yQmAIgIj4i0iBjArSGGOSYe2XuSmWrRtfl0tE1nus/6SqCY/+B4vIRpxvqX3dsuHAxyLyNHAMeMgtfwKYKCKP4HyTHQIcTu/gjTHZmrVfJs3YPXQmS3LvQQlT1ePejsUYY26GtV/mVtiQqzHGGGOMj7MeOmOMMcYYH2c9dMYYY4wxPs4SOmOMMcYYH2cJnTHGGGOMj7OEzhhjjDHGx1lCZ4wxxhjj4yyhM8YYY4zxcf8PmdCy+ANNp1UAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_model_history(simple_model_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Convolutional Networks\n",
    "\n",
    "\n",
    "Convolutional Neural Networks or\n",
    "CNNs are networks designed to work with images or with any regularly\n",
    "sampled dataset. CNNs reduce the complexity of the network by\n",
    "requiring that neurons only respond to inputs from a subset of an\n",
    "image (the receptive field). This mimics the operation of the visual\n",
    "cortex where neurons only respond to a small part of the\n",
    "field-of-view.\n",
    "\n",
    "There are four principal components to a CNN:\n",
    "- a convolutional layer,\n",
    "- a _non-linear activation function_ ,\n",
    "- a pooling or downsampling operation, and\n",
    "- a _fully connected layer for classification_\n",
    "\n",
    "Dependent on the complexity of the network or structure of the data,\n",
    "these components can occur singularly or chained together in multiple\n",
    "sequences."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Convolutional Neural Network](figures/fig_cnn_1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Convolution** in a CNN refers to the convolution  of the input data\n",
    "$I(x,y)$ with a kernel $K(x,y)$ which will produce a feature map $F(x,y)$\n",
    "\n",
    "\\begin{equation}\n",
    "F(x,y) = K(x,y) * I(x,y)  = \\sum_{x_0} \\sum_{y_0} I(x-x_0, y-y_0) K(x_0, y_0).\n",
    "\\end{equation}\n",
    "\n",
    "The kernel only responds to pixels within its receptive field (i.e.,\n",
    "the size of the kernel), reducing the computational complexity of the\n",
    "resulting network. The kernels in the convolution are described by a\n",
    "depth (the number of kernels, $K$, applied to the image), and a stride\n",
    "(how many pixels a kernel shifts at each step in the convolution;\n",
    "typically one).  Given an $N\\times M$ image, the result of the\n",
    "convolution step is to transform a single image into a data cube of\n",
    "feature maps with a dimension $N \\times M \\times K$.\n",
    "\n",
    "Once **learned** the kernels within the convolutional layer can appear\n",
    "as physically intuitive operations on the images \n",
    "such as edge detection filters.\n",
    "\n",
    "\n",
    "As with traditional neural networks, a non-linear activation function\n",
    "is applied to the individual pixels in the resulting feature\n",
    "maps. \n",
    "\n",
    "\n",
    "The **pooling** in the CNN downsamples or subsamples the feature maps. Pooling summarizes values within a region\n",
    "of interest (e.g., a 2x2 pixel window). The summary can be the average\n",
    "pixel value but more commonly the maximum pixel value is preserved\n",
    "(Max Pooling) in the downsampling. This pooling of the feature maps\n",
    "reduces the size of the resulting network and makes the network less\n",
    "sensitive to small translations or distortions between images.\n",
    "\n",
    "\n",
    "\n",
    "The final layer of a CNN is the classification layer which maps the\n",
    "output of the CNN to a set of labels. This is typically a fully\n",
    "connected layer where each output\n",
    "of the final pooling layer connects to all neurons in the\n",
    "classification layer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CNNs: Increasing the complexity of the architecture with VGG6\n",
    "\n",
    "Let's start with a simple network architecture from Oxford's Visual Geometry Group. VGG6 is a very simple network that performs well in traditional image classification competitions (e.g. those using the ImageNet data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Conv2D, Flatten\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "\n",
    "def vgg6(input_shape=(21, 21, 1), n_classes: int = 2):\n",
    "    \"\"\"\n",
    "        VGG6\n",
    "    :param input_shape:\n",
    "    :param n_classes:\n",
    "    :return:\n",
    "    \"\"\"\n",
    "\n",
    "    model = tf.keras.models.Sequential(name='VGG6')\n",
    "    # input: 21x21 images with 1 channel -> (21, 21, 1) tensors.\n",
    "    # this applies 16 convolution filters of size 3x3 each.\n",
    "    model.add(tf.keras.layers.Conv2D(16, (3, 3), activation='relu', input_shape=input_shape, name='conv1'))\n",
    "    model.add(tf.keras.layers.Conv2D(16, (3, 3), activation='relu', name='conv2'))\n",
    "    model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\n",
    "    model.add(tf.keras.layers.Dropout(0.25))\n",
    "\n",
    "    model.add(tf.keras.layers.Conv2D(32, (3, 3), activation='relu', name='conv3'))\n",
    "    model.add(tf.keras.layers.Conv2D(32, (3, 3), activation='relu', name='conv4'))\n",
    "    model.add(tf.keras.layers.BatchNormalization(axis = 3, name = 'bn_2'))\n",
    "    model.add(tf.keras.layers.MaxPooling2D(pool_size=(4, 4)))\n",
    "    model.add(tf.keras.layers.Dropout(0.25))\n",
    "\n",
    "    model.add(tf.keras.layers.Flatten())\n",
    "\n",
    "    model.add(tf.keras.layers.Dense(256, activation='relu', name='fc_1'))\n",
    "    model.add(tf.keras.layers.Dropout(0.5))\n",
    "    # output layer\n",
    "    activation = 'sigmoid' if n_classes == 1 else 'softmax'\n",
    "    model.add(tf.keras.layers.Dense(n_classes, activation=activation, name='fc_out'))\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The use of dropout layers\n",
    "\n",
    "As we increase the complexity of the network we run into the issue of overfitting the data (as seen in many of the astroML examples). The dropout layer ```model.add(tf.keras.layers.Dropout(0.5))``` at each training epoch randomly sets a neuron to 0 with a probability of 0.5. There is debate over whether the dropout layer should come before or after an activation layer but a recommended rule of thumb is that it should come after the activation layer for activation functions other than relu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"VGG6\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv1 (Conv2D)               (None, 19, 19, 16)        160       \n",
      "_________________________________________________________________\n",
      "conv2 (Conv2D)               (None, 17, 17, 16)        2320      \n",
      "_________________________________________________________________\n",
      "max_pooling2d (MaxPooling2D) (None, 8, 8, 16)          0         \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 8, 8, 16)          0         \n",
      "_________________________________________________________________\n",
      "conv3 (Conv2D)               (None, 6, 6, 32)          4640      \n",
      "_________________________________________________________________\n",
      "conv4 (Conv2D)               (None, 4, 4, 32)          9248      \n",
      "_________________________________________________________________\n",
      "bn_2 (BatchNormalization)    (None, 4, 4, 32)          128       \n",
      "_________________________________________________________________\n",
      "max_pooling2d_1 (MaxPooling2 (None, 1, 1, 32)          0         \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 1, 1, 32)          0         \n",
      "_________________________________________________________________\n",
      "flatten_2 (Flatten)          (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "fc_1 (Dense)                 (None, 256)               8448      \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 256)               0         \n",
      "_________________________________________________________________\n",
      "fc_out (Dense)               (None, 2)                 514       \n",
      "=================================================================\n",
      "Total params: 25,458\n",
      "Trainable params: 25,394\n",
      "Non-trainable params: 64\n",
      "_________________________________________________________________\n",
      "Epoch 1/15\n",
      "75/75 - 13s - loss: 0.6890 - accuracy: 0.5519 - val_loss: 0.6904 - val_accuracy: 0.5499\n",
      "Epoch 2/15\n",
      "75/75 - 13s - loss: 0.6869 - accuracy: 0.5557 - val_loss: 0.6892 - val_accuracy: 0.5499\n",
      "Epoch 3/15\n",
      "75/75 - 13s - loss: 0.6845 - accuracy: 0.5594 - val_loss: 0.6881 - val_accuracy: 0.5499\n",
      "Epoch 4/15\n",
      "75/75 - 13s - loss: 0.6807 - accuracy: 0.5685 - val_loss: 0.6866 - val_accuracy: 0.5499\n",
      "Epoch 5/15\n",
      "75/75 - 13s - loss: 0.6779 - accuracy: 0.5772 - val_loss: 0.6850 - val_accuracy: 0.5499\n",
      "Epoch 6/15\n",
      "75/75 - 13s - loss: 0.6747 - accuracy: 0.5922 - val_loss: 0.6831 - val_accuracy: 0.5507\n",
      "Epoch 7/15\n",
      "75/75 - 13s - loss: 0.6714 - accuracy: 0.6051 - val_loss: 0.6798 - val_accuracy: 0.5501\n",
      "Epoch 8/15\n",
      "75/75 - 13s - loss: 0.6675 - accuracy: 0.6169 - val_loss: 0.6759 - val_accuracy: 0.5520\n",
      "Epoch 9/15\n",
      "75/75 - 13s - loss: 0.6628 - accuracy: 0.6290 - val_loss: 0.6693 - val_accuracy: 0.5617\n",
      "Epoch 10/15\n",
      "75/75 - 13s - loss: 0.6579 - accuracy: 0.6362 - val_loss: 0.7803 - val_accuracy: 0.4501\n",
      "Epoch 11/15\n",
      "75/75 - 13s - loss: 0.6523 - accuracy: 0.6394 - val_loss: 0.7370 - val_accuracy: 0.5500\n",
      "Epoch 12/15\n",
      "75/75 - 13s - loss: 0.6451 - accuracy: 0.6452 - val_loss: 0.7329 - val_accuracy: 0.5504\n",
      "Epoch 13/15\n",
      "75/75 - 13s - loss: 0.6398 - accuracy: 0.6427 - val_loss: 0.7394 - val_accuracy: 0.5534\n",
      "Epoch 14/15\n",
      "75/75 - 13s - loss: 0.6337 - accuracy: 0.6444 - val_loss: 1.0248 - val_accuracy: 0.5499\n",
      "Epoch 15/15\n",
      "75/75 - 13s - loss: 0.6285 - accuracy: 0.6464 - val_loss: 0.6993 - val_accuracy: 0.5504\n"
     ]
    }
   ],
   "source": [
    "vgg_model = vgg6()\n",
    "vgg_model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])\n",
    "n_epochs=15\n",
    "vgg_model.summary()\n",
    "vgg_model_history = vgg_model.fit(data_train, class_train, epochs=n_epochs, batch_size=1024, verbose=2, \n",
    "                                  validation_data=(data_val, class_val), shuffle=True)\n",
    "classes = vgg_model.predict(data_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the confusion matrix\n",
    "plot_confusion_matrix(np.argmax(class_test,axis=1), np.argmax(classes,axis=1), normalize=True,\n",
    "                      title='Normalized confusion matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the training history\n",
    "plot_model_history(vgg_model_history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x720 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot example classifications\n",
    "plot_image_array(data_val, figsize=[16,10], subtitle=True, classes=classes, class_true=class_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interpreting networks: how many layers and how many neurons?\n",
    "\n",
    "The number of layers, number of neurons in a layer, and the\n",
    "connectivity of these layers is typically described as the network\n",
    "architecture.  \n",
    "\n",
    "\n",
    "Approaches to defining a network\n",
    "architecture become more trial and error than applying an underlying\n",
    "set of principles. For a starting point, however, there are relatively\n",
    "few problems that benefit significantly from more than two layers and\n",
    "we recommend starting with a single layer when training an initial\n",
    "network and using cross-validation to determine when additional layers\n",
    "lead result in the data being overfit.\n",
    "\n",
    "As with the number of layers, the number of neurons within a layer\n",
    "drives the computational cost (and requiring progressively larger\n",
    "training sets to avoid overfitting of the data). There are many\n",
    "proposals for rules of thumb for defining a network architecture:\n",
    "- the number of neurons should lie between the number of inputs and output nodes\n",
    "- the number of neurons should be equal to the number of outputs plus 2/3rd the number input nodes.\n",
    "- the number of neurons in the hidden layer should be less than twice the size of the input layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interpreting networks: where is a network looking\n",
    "\n",
    "Occulsion maps, saliency maps, class activation maps are all techniques for expressing which pixels contribute to classification. These are attempts to reduce the \"black box\" nature of the networks. The simplest of these is the occlussion map where we part of an image and calculate the probability of it belonging to a class. If the probability decreases the occluded part of the image is assumed to be important. If there is no change in probability the occluded pixels are not assumed to be important. A simple implementation of this is shown here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x196d13f10>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = vgg_model\n",
    "image_number = 11\n",
    "\n",
    "kernel_size=5\n",
    "input_stamp = data_test[image_number].reshape(21,21)\n",
    "i = 0\n",
    "j=0\n",
    "heatmap = []\n",
    "keras_stamps = []\n",
    "for j in range(22-kernel_size):\n",
    "    for i in range(22-kernel_size):\n",
    "        img = np.copy(input_stamp)\n",
    "        img[i:i+kernel_size,j:j+kernel_size] = 0\n",
    "        img = normalize_image(img)\n",
    "        keras_stamps.append(img)\n",
    "keras_stamps = np.array(keras_stamps).reshape([-1,21,21,1])\n",
    "probs = 1. - model.predict(keras_stamps)\n",
    "heatmap = probs[:,1].reshape(22-kernel_size,22-kernel_size)\n",
    "\n",
    "def transparent_cmap(cmap, N=255):\n",
    "    \"Copy colormap and set alpha values\"\n",
    "    mycmap = cmap\n",
    "    mycmap._init()\n",
    "    mycmap._lut[:,-1] = np.linspace(0, 0.8, N+4)\n",
    "    return mycmap\n",
    "\n",
    "# pad heatmap to same size as original image\n",
    "heatmap = np.pad(heatmap, pad_width=np.int(kernel_size/2), mode='minimum')\n",
    "\n",
    "# use the base cmap to create transparent overlay\n",
    "mycmap = transparent_cmap(plt.cm.Reds)\n",
    "fig, ax = plt.subplots(nrows=1,ncols=1)\n",
    "ax.imshow(data_test[image_number].reshape(21,21), cmap='gray')\n",
    "ax.imshow(np.array(heatmap), alpha=0.5, cmap=mycmap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise for the reader: more complicated architectures: resnet50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Based on https://github.com/priya-dwivedi/Deep-Learning/blob/master/resnet_keras/Residual_Networks_yourself.ipynb\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.layers import Input, Add, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D, AveragePooling2D, MaxPooling2D, GlobalMaxPooling2D\n",
    "from tensorflow.keras.initializers import glorot_uniform\n",
    "from tensorflow.keras.models import Model, load_model\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "import tensorflow.keras.backend as K\n",
    "K.set_image_data_format('channels_last')\n",
    "def identity_block(X, f, filters, stage, block):\n",
    "    \"\"\"\n",
    "    Implementation of the identity block as defined in Figure 3\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)\n",
    "    f -- integer, specifying the shape of the middle CONV's window for the main path\n",
    "    filters -- python list of integers, defining the number of filters in the CONV layers of the main path\n",
    "    stage -- integer, used to name the layers, depending on their position in the network\n",
    "    block -- string/character, used to name the layers, depending on their position in the network\n",
    "    \n",
    "    Returns:\n",
    "    X -- output of the identity block, tensor of shape (n_H, n_W, n_C)\n",
    "    \"\"\"\n",
    "    \n",
    "    # defining name basis\n",
    "    conv_name_base = 'res' + str(stage) + block + '_branch'\n",
    "    bn_name_base = 'bn' + str(stage) + block + '_branch'\n",
    "    \n",
    "    # Retrieve Filters\n",
    "    F1, F2, F3 = filters\n",
    "    \n",
    "    # Save the input value. You'll need this later to add back to the main path. \n",
    "    X_shortcut = X\n",
    "    \n",
    "    # First component of main path\n",
    "    X = Conv2D(filters = F1, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n",
    "    X = Activation('relu')(X)\n",
    "\n",
    "    \n",
    "    # Second component of main path (≈3 lines)\n",
    "    X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n",
    "    X = Activation('relu')(X)\n",
    "\n",
    "    # Third component of main path (≈2 lines)\n",
    "    X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n",
    "\n",
    "    # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)\n",
    "    X = Add()([X, X_shortcut])\n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    return X\n",
    "\n",
    "def convolutional_block(X, f, filters, stage, block, s = 2):\n",
    "    \"\"\"\n",
    "    Implementation of the convolutional block as defined in Figure 4\n",
    "    \n",
    "    Arguments:\n",
    "    X -- input tensor of shape (m, n_H_prev, n_W_prev, n_C_prev)\n",
    "    f -- integer, specifying the shape of the middle CONV's window for the main path\n",
    "    filters -- python list of integers, defining the number of filters in the CONV layers of the main path\n",
    "    stage -- integer, used to name the layers, depending on their position in the network\n",
    "    block -- string/character, used to name the layers, depending on their position in the network\n",
    "    s -- Integer, specifying the stride to be used\n",
    "    \n",
    "    Returns:\n",
    "    X -- output of the convolutional block, tensor of shape (n_H, n_W, n_C)\n",
    "    \"\"\"\n",
    "    \n",
    "    # defining name basis\n",
    "    conv_name_base = 'res' + str(stage) + block + '_branch'\n",
    "    bn_name_base = 'bn' + str(stage) + block + '_branch'\n",
    "    \n",
    "    # Retrieve Filters\n",
    "    F1, F2, F3 = filters\n",
    "    \n",
    "    # Save the input value\n",
    "    X_shortcut = X\n",
    "\n",
    "\n",
    "    ##### MAIN PATH #####\n",
    "    # First component of main path \n",
    "    X = Conv2D(F1, (1, 1), strides = (s,s), name = conv_name_base + '2a', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2a')(X)\n",
    "    X = Activation('relu')(X)\n",
    "\n",
    "    # Second component of main path (≈3 lines)\n",
    "    X = Conv2D(filters = F2, kernel_size = (f, f), strides = (1,1), padding = 'same', name = conv_name_base + '2b', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2b')(X)\n",
    "    X = Activation('relu')(X)\n",
    "\n",
    "\n",
    "    # Third component of main path (≈2 lines)\n",
    "    X = Conv2D(filters = F3, kernel_size = (1, 1), strides = (1,1), padding = 'valid', name = conv_name_base + '2c', kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis = 3, name = bn_name_base + '2c')(X)\n",
    "\n",
    "\n",
    "    ##### SHORTCUT PATH #### (≈2 lines)\n",
    "    X_shortcut = Conv2D(filters = F3, kernel_size = (1, 1), strides = (s,s), padding = 'valid', name = conv_name_base + '1',\n",
    "                        kernel_initializer = glorot_uniform(seed=0))(X_shortcut)\n",
    "    X_shortcut = BatchNormalization(axis = 3, name = bn_name_base + '1')(X_shortcut)\n",
    "\n",
    "    # Final step: Add shortcut value to main path, and pass it through a RELU activation (≈2 lines)\n",
    "    X = Add()([X, X_shortcut])\n",
    "    X = Activation('relu')(X)\n",
    "    \n",
    "    \n",
    "    return X\n",
    "\n",
    "def ResNet50(input_shape=(21, 21, 1), classes=2):\n",
    "    \"\"\"\n",
    "    Implementation of the popular ResNet50 the following architecture:\n",
    "    CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3\n",
    "    -> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER\n",
    "\n",
    "    Arguments:\n",
    "    input_shape -- shape of the images of the dataset\n",
    "    classes -- integer, number of classes\n",
    "\n",
    "    Returns:\n",
    "    model -- a Model() instance in Keras\n",
    "    \"\"\"\n",
    "\n",
    "    # Define the input as a tensor with shape input_shape\n",
    "    X_input = Input(input_shape)\n",
    "\n",
    "    # Zero-Padding\n",
    "    X = ZeroPadding2D((3, 3))(X_input)\n",
    "\n",
    "    # Stage 1\n",
    "    X = Conv2D(64, (7, 7), strides=(2, 2), name='conv1', kernel_initializer=glorot_uniform(seed=0))(X)\n",
    "    X = BatchNormalization(axis=3, name='bn_conv1')(X)\n",
    "    X = Activation('relu')(X)\n",
    "    X = MaxPooling2D((3, 3), strides=(2, 2))(X)\n",
    "\n",
    "    # Stage 2\n",
    "    X = convolutional_block(X, f=3, filters=[64, 64, 256], stage=2, block='a', s=1)\n",
    "    X = identity_block(X, 3, [64, 64, 256], stage=2, block='b')\n",
    "    X = identity_block(X, 3, [64, 64, 256], stage=2, block='c')\n",
    "\n",
    "    ### START CODE HERE ###\n",
    "\n",
    "    # Stage 3 (≈4 lines)\n",
    "    X = convolutional_block(X, f = 3, filters = [128, 128, 512], stage = 3, block='a', s = 2)\n",
    "    X = identity_block(X, 3, [128, 128, 512], stage=3, block='b')\n",
    "    X = identity_block(X, 3, [128, 128, 512], stage=3, block='c')\n",
    "    X = identity_block(X, 3, [128, 128, 512], stage=3, block='d')\n",
    "\n",
    "    # Stage 4 (≈6 lines)\n",
    "    X = convolutional_block(X, f = 3, filters = [256, 256, 1024], stage = 4, block='a', s = 2)\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b')\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='c')\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='d')\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='e')\n",
    "    X = identity_block(X, 3, [256, 256, 1024], stage=4, block='f')\n",
    "\n",
    "    # Stage 5 (≈3 lines)\n",
    "    X = convolutional_block(X, f = 3, filters = [512, 512, 2048], stage = 5, block='a', s = 2)\n",
    "    X = identity_block(X, 3, [512, 512, 2048], stage=5, block='b')\n",
    "    X = identity_block(X, 3, [512, 512, 2048], stage=5, block='c')\n",
    "\n",
    "    # AVGPOOL (≈1 line). Use \"X = AveragePooling2D(...)(X)\"\n",
    "    #X = AveragePooling2D((2,2), name=\"avg_pool\")(X)\n",
    "\n",
    "    ### END CODE HERE ###\n",
    "\n",
    "    # output layer\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(classes, activation='softmax', name='fc' + str(classes), kernel_initializer = glorot_uniform(seed=0))(X)\n",
    "    \n",
    "    \n",
    "    # Create model\n",
    "    model = Model(inputs = X_input, outputs = X, name='ResNet50')\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resnet50_model = ResNet50()\n",
    "resnet50_model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])\n",
    "n_epochs=5\n",
    "resnet_model_history = resnet50_model.fit(data_train, class_train, epochs=n_epochs, batch_size=256, verbose=1, \n",
    "                                          validation_data=(data_val, class_val), shuffle=True)"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,md:myst"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}