21-EX-MLP-v1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creative Commons CC BY 4.0 Lynd Bacon & Associates, Ltd. Not warranted to be suitable for any particular purpose. (You're on your own!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer Perceptrons\n",
    "\n",
    "In the following we're going to train MLPs.  We'll start with a modest data set that has a half dozen features, and that we'll train a MLP to predict a binary target variable.  Then we'll train MLPs to predict the labels on digit images that is widely used to test a variety of predictive algorithms.  Both are larger datasets.  NNs have a voracious appetite for data.\n",
    "\n",
    "We'll use the packages [Tensorflow](http://tensorflow.org) and [Keras](https://keras.io/), the latter being well integrated into the former in recent version releases. See [Keras in Tensorflow](https://www.tensorflow.org/beta/guide/keras)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NN  Parameters\n",
    "\n",
    "There are many parameters to set, and to \"tweak\" to try to improve performance.  They include:\n",
    "\n",
    "* Learning rate:  this is the \"step size\" adjustment taken to update the values of weights upon evaluation of the gradient. \n",
    "* Optimizer selection: there are several available.\n",
    "    * For a summary of those available in Tensorflow, see [Tensorflow Optimizers](https://www.tutorialspoint.com/tensorflow/tensorflow_optimizers).\n",
    "* Number of layers.\n",
    "* Number of nodes per layer.\n",
    "* Activation function(s).\n",
    "* Number of epochs: an epoch is a single forward pass and backward pass over the training examples.\n",
    "* Batch size: the number of training examples in an epoch. (Sometimes called a _mini-batch_ to make it clear that the training examples in an epoch may not be the entire set of htem.)\n",
    "\n",
    "If you have 5,000 training examples, and your batch size is 100, an epoch will require fifty (50) iterations.\n",
    "\n",
    "It may be the case that, ceteris paribus, smaller batches will result in better generalization than larger ones. See [On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima](https://arxiv.org/abs/1609.04836)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\"\n",
    "from IPython.display import display, Markdown\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import scikitplot as skplt\n",
    "from sklearn import linear_model\n",
    "from sklearn.model_selection import KFold, StratifiedShuffleSplit\n",
    "from sklearn.model_selection import cross_val_predict, train_test_split\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn import preprocessing\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, roc_auc_score\n",
    "from sklearn.metrics import roc_curve, precision_score, recall_score\n",
    "from sklearn.metrics import classification_report\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mammography Data: Input and Munging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['attr1', 'attr2', 'attr3', 'attr4', 'attr5', 'attr6', 'class'], dtype='object')"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>attr1</th>\n",
       "      <th>attr2</th>\n",
       "      <th>attr3</th>\n",
       "      <th>attr4</th>\n",
       "      <th>attr5</th>\n",
       "      <th>attr6</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>1.118300e+04</td>\n",
       "      <td>1.118300e+04</td>\n",
       "      <td>1.118300e+04</td>\n",
       "      <td>1.118300e+04</td>\n",
       "      <td>1.118300e+04</td>\n",
       "      <td>1.118300e+04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>1.096535e-10</td>\n",
       "      <td>1.297595e-09</td>\n",
       "      <td>5.698113e-10</td>\n",
       "      <td>-2.435705e-09</td>\n",
       "      <td>-1.120680e-09</td>\n",
       "      <td>1.459483e-09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>1.000000e+00</td>\n",
       "      <td>1.000000e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>-7.844148e-01</td>\n",
       "      <td>-4.701953e-01</td>\n",
       "      <td>-5.916315e-01</td>\n",
       "      <td>-8.595525e-01</td>\n",
       "      <td>-3.778657e-01</td>\n",
       "      <td>-9.457232e-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>-7.844148e-01</td>\n",
       "      <td>-4.701953e-01</td>\n",
       "      <td>-5.916315e-01</td>\n",
       "      <td>-8.595525e-01</td>\n",
       "      <td>-3.778657e-01</td>\n",
       "      <td>-9.457232e-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>-1.085769e-01</td>\n",
       "      <td>-3.949941e-01</td>\n",
       "      <td>-2.309790e-01</td>\n",
       "      <td>-8.595525e-01</td>\n",
       "      <td>-3.778657e-01</td>\n",
       "      <td>-9.457232e-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>3.139489e-01</td>\n",
       "      <td>-7.649473e-02</td>\n",
       "      <td>2.198366e-01</td>\n",
       "      <td>8.202077e-01</td>\n",
       "      <td>-3.778657e-01</td>\n",
       "      <td>1.016613e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>3.150844e+01</td>\n",
       "      <td>5.085849e+00</td>\n",
       "      <td>2.947777e+01</td>\n",
       "      <td>9.591164e+00</td>\n",
       "      <td>2.361712e+01</td>\n",
       "      <td>1.949027e+00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              attr1         attr2         attr3         attr4         attr5  \\\n",
       "count  1.118300e+04  1.118300e+04  1.118300e+04  1.118300e+04  1.118300e+04   \n",
       "mean   1.096535e-10  1.297595e-09  5.698113e-10 -2.435705e-09 -1.120680e-09   \n",
       "std    1.000000e+00  1.000000e+00  1.000000e+00  1.000000e+00  1.000000e+00   \n",
       "min   -7.844148e-01 -4.701953e-01 -5.916315e-01 -8.595525e-01 -3.778657e-01   \n",
       "25%   -7.844148e-01 -4.701953e-01 -5.916315e-01 -8.595525e-01 -3.778657e-01   \n",
       "50%   -1.085769e-01 -3.949941e-01 -2.309790e-01 -8.595525e-01 -3.778657e-01   \n",
       "75%    3.139489e-01 -7.649473e-02  2.198366e-01  8.202077e-01 -3.778657e-01   \n",
       "max    3.150844e+01  5.085849e+00  2.947777e+01  9.591164e+00  2.361712e+01   \n",
       "\n",
       "              attr6  \n",
       "count  1.118300e+04  \n",
       "mean   1.459483e-09  \n",
       "std    1.000000e+00  \n",
       "min   -9.457232e-01  \n",
       "25%   -9.457232e-01  \n",
       "50%   -9.457232e-01  \n",
       "75%    1.016613e+00  \n",
       "max    1.949027e+00  "
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'-1'    10923\n",
       "'1'       260\n",
       "Name: class, dtype: int64"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mammogram = pd.read_csv('DATA/ML/mammography.csv')\n",
    "mammogram.columns\n",
    "mammogram.describe()\n",
    "mammogram['class'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_class_ is the target variable.  Its two categories are labeled as '-1' and '1'.  Let's create a new target by coded 0 and 1, and then we'll drop _class_. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    10923\n",
       "1      260\n",
       "Name: target, dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Index(['attr1', 'attr2', 'attr3', 'attr4', 'attr5', 'attr6', 'target'], dtype='object')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mammogram['target']=mammogram['class'].replace({\"'-1'\":0,\"'1'\":1})\n",
    "mammogram.target.value_counts()\n",
    "mammogram2=mammogram.drop('class',axis=1)\n",
    "mammogram2.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Create numpy arrays\n",
    "\n",
    "X=mammogram.iloc[:,:6].to_numpy()  # features\n",
    "y=pd.get_dummies(mammogram.target)\n",
    "# y.sum(axis=0)\n",
    "y=y.to_numpy()   # target"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training, Test, and Validation Splits \n",
    "\n",
    "We'll use 80% of the data for training and testing, and the remaining 20% for final validation of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(99)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "stratSplit=StratifiedShuffleSplit(\n",
    "        n_splits=1,\n",
    "        test_size=0.40,\n",
    "        random_state=99\n",
    "        )\n",
    "for trainNdx,testNdx in stratSplit.split(X,y):\n",
    "    X_train=X[trainNdx]\n",
    "    y_train=y[trainNdx]\n",
    "    X_test0=X[testNdx]\n",
    "    y_test0=y[testNdx]\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "stratSplit=StratifiedShuffleSplit(\n",
    "        n_splits=1,\n",
    "        test_size=0.50,\n",
    "        random_state=99\n",
    "            )\n",
    "for valNdx, testNdx in stratSplit.split(X_test0,y_test0):\n",
    "        X_valid=X_test0[valNdx]\n",
    "        y_valid=y_test0[valNdx]\n",
    "        X_test=X_test0[testNdx]\n",
    "        y_test=y_test0[testNdx]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MLP with Tensorflow and Keras \n",
    "\n",
    "We'll being with training a single hidden layer feedforward NLP that predicts our target variable using the six features attr1 through attr6 as inputs.\n",
    "\n",
    "A \"Sequential\" Keras model is just a \"stack\" of layers connected sequentially."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network Specification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can use the following to reset the graph, or to wipe it out completely.\n",
    "keras.backend.clear_session()  # this resets\n",
    " #del(mlp)                       # this deletes the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "mlp = keras.models.Sequential() #stacked layers \n",
    "mlp.add(keras.layers.Dense(4,activation='relu',input_shape=(6,))) # six features per row in X\n",
    "mlp.add(keras.layers.Dense(2,activation=\"softmax\"))  # output layer: two categories, normalized to get probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tensorflow.python.keras.layers.core.Dense at 0x7f5e9b70c550>,\n",
       " <tensorflow.python.keras.layers.core.Dense at 0x7f5e9b70c7f0>]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Verifying the layers\n",
    "mlp.layers "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 4)                 28        \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 2)                 10        \n",
      "=================================================================\n",
      "Total params: 38\n",
      "Trainable params: 38\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "mlp.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "## compile the network\n",
    "\n",
    "mlp.compile(loss='categorical_crossentropy',\n",
    "           optimizer='sgd',\n",
    "           metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_sdg_, above is \"stochastic gradient descent.\"\n",
    "\n",
    "Keras provides a number of predefined loss functions.  See:\n",
    "\n",
    "[Keras Loss Functions](https://keras.io/losses/)\n",
    "\n",
    "Metrics:\n",
    "\n",
    "[Keras metrics](https://keras.io/metrics/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "Output epoch by epoch is surpressed by _verbose_=0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlpTraining=mlp.fit(X_train,y_train,epochs=50,verbose=0,\n",
    "                   validation_data=(X_test,y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training By Epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "historyDF=pd.DataFrame(mlp.history.history)\n",
    "historyDF.plot(figsize=(8,5))\n",
    "plt.grid(True)\n",
    "plt.gca().set_ylim(0,1)\n",
    "plt.title(\"Training and Test Metrics by Epoch\")\n",
    "plt.xlabel('Epoch Number')\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like training had \"converged\" by about half way through the epochs.  _But do you see anything odd?_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "historyDF=pd.DataFrame(mlp.history.history).iloc[:6,:]\n",
    "historyDF.plot(figsize=(8,5))\n",
    "plt.grid(True)\n",
    "plt.gca().set_ylim(0,1)\n",
    "plt.title(\"Training and Test Metrics by Epoch\")\n",
    "plt.xlabel('Epoch Number')\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the training and test metrics are not computed at the same time.  The training metrics are computed during an epoch.  The test metrics are computed at the _end_ of an epoch.  So the training measures should be shifted to the left w.r.t. the test metrics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation\n",
    "\n",
    "Loss and accuracy on the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Data: loss 0.051 accuracy 0.985\n"
     ]
    }
   ],
   "source": [
    "testEval=mlp.evaluate(X_test,y_test,verbose=0)\n",
    "print(\"Test Data: loss {:1.3f} accuracy {:1.3f}\".format(testEval[0],testEval[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loss and accuracy on the _validation_ data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Data: loss 0.064 accuracy 0.983\n"
     ]
    }
   ],
   "source": [
    "valEval=mlp.evaluate(X_valid,y_valid,verbose=0)\n",
    "print(\"Validation Data: loss {:1.3f} accuracy {:1.3f}\".format(valEval[0],valEval[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction\n",
    "\n",
    "This is done pretty much like with scikit-learn methods.\n",
    "\n",
    "Let's predict using the validation data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2218\n",
       "1      19\n",
       "dtype: int64"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred=mlp.predict_classes(X_valid)\n",
    "pd.Series(y_pred).value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confusion!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2182,    3],\n",
       "       [  36,   16]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(y_valid[:,1],y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classification Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Summary Based on Validation Data\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      1.00      0.99      2185\n",
      "           1       0.84      0.31      0.45        52\n",
      "\n",
      "    accuracy                           0.98      2237\n",
      "   macro avg       0.91      0.65      0.72      2237\n",
      "weighted avg       0.98      0.98      0.98      2237\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Classification Summary Based on Validation Data\\n\")\n",
    "print(classification_report(y_valid[:,1],y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predicted Probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    2.237000e+03\n",
       "mean     2.316242e-02\n",
       "std      8.215000e-02\n",
       "min      5.236859e-11\n",
       "25%      1.275275e-03\n",
       "50%      4.671413e-03\n",
       "75%      1.382906e-02\n",
       "max      9.945709e-01\n",
       "dtype: float64"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_predProb=mlp.predict_proba(X_valid)\n",
    "pd.Series(y_predProb[:,1]).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2237, 2)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(2237, 2)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_valid.shape\n",
    "y_predProb.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC, AUC \n",
    "\n",
    "Note that \"skplt.metrics.plot_roc()\" expects a _matrix_ of predicted probabilities, one col per class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcIAAAG5CAYAAAAd/TRHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3gU1f7H8ffZTa+EXqQX6U1EEVSQLkVAimJDKXasF/WqPxVFLFcUBUQsF0HggqKAUkJAOihFCaFKb4EAIb1nc35/7BJSNskSsplN9vt6njxmZs7OfgKS754zZ84orTVCCCGEuzIZHUAIIYQwkhRCIYQQbk0KoRBCCLcmhVAIIYRbk0IohBDCrUkhFEII4dakEAoBKKXqKaW0UsrDtr1SKfWII22L8V7/Vkp9cz15hRAlRwqhKBeUUqFKqYl29t+jlDp/rUVLa91Xa/19CeTqqpQ6k+fc72utx1zvue281yillEUplWj7Oq6U+q9Sqsk1nGO2Uuq968jwtlIqw/b+sUqprUqpTnnaVFBKfWn7e0lWSkUopR61c66RSqmdtnOds3046VLcbEIURAqhKC9mAw8ppVSe/Q8B87TWmaUfyRDbtNYBQDDQA0gBdimlWpZihoW2DJWBdcCPVw4opbyANUBdoJMt57+AD5RSL+Zo9yLwGfA+UA2oA8wA7imln0G4E621fMlXmf8CfIE44I4c+0KAVKCNbbsf8DcQD5wG3s7Rth6gAQ/b9npgjO17M/Af4BJwDHg6T9tHgQNAgu3447b9/lgLURaQaPuqCbwN/JDjvQcC+4BY2/s2y3HsBPAysMf28y0EfAr4MxgFbLaz/zfgpxzbPwLnbefbCLSw7R8HZADptqy/2va/Chy1/Xz7gcGF/D3k/dma2/6sqti2RwMXAP88rxthe88grMUxERhm9P9X8uUeX9IjFOWC1joFWAQ8nGP3cOCg1jrctp1kO14Ba1F8Uik1yIHTjwX6A+2ADsDQPMcv2I4HYS2Knyql2mutk4C+QKTWOsD2FZnzhbZhywXA80AVYAXwq63nlPPn6APUB1pjLXjX4mfg9hzbK4HGQFXgL2AegNZ6lu37j2xZB9jaH7W9Phh4B/hBKVWjqDe1/QwPA9FAjG13T2Cl7c8mp8WAD9ZeYifb979c248pRPFIIRTlyffAMKWUr237Yds+ALTW67XWEVrrLK31HqwF6E4Hzjsc+ExrfVprfRmYnPOg1nq51vqottoArCZ34SnMCGC51jpMa52BtefpC9yWo83nWutI23v/CrR18NxXRAIVc+T9TmudoLVOw9qDa6OUCi7oxVrrH23vn6W1XggcBjoW8n7DlVKxWHvDY4Gh+urQdGXgnJ33yMTa464MVAIuafcZzhYGk0Ioyg2t9WbgInCPUqoBcDMw/8pxpdQtSql1SqmLSqk44Amsv3iLUhPrUOoVJ3MeVEr1VUr9oZS6bCsAdzt43ivnzj6f1jrL9l61crQ5n+P7ZCDAwXNfUQu4bMtqVkp9oJQ6qpSKxzr0SmF5lVIPK6V22ya/xAItC2sPLNJaV8B6bW8vcFOOY5eAfL1J22Smyrbj0UDl4s7KFeJaSSEU5c0crD3Bh4DVWuuoHMfmA8uA2lrrYGAmkHdyjT3ngNo5tutc+UYp5Y11WO8/QDVbAViR47xFPd4lEuvEkSvnU7b3OutALkcNBjbZvh+JdcJJD6xDnfWuvLXtv7nyKqXqAl8DzwCVbD/fXhz4c9NaXwIeB97OMZS6BuirlPLP0/xeIA34A9iG9dquI8PWQlw3KYSivJmD9Zf8WHIMi9oEApe11qlKqY5Yi4IjFgHjlVI3KKVCsE4eucIL8MbaE81USvUFeuU4HgVUKmTocRHQTynVXSnlCbyEtSBsdTCbXbaeX32l1BdAV6zX9sD6Z5CGtdflh3VWZk5RQIMc2/5Yi+NF23kfxdojdIjW+iAQCkyw7ZoLnAF+tN2P6amU6g18jnXyUpzWOg74P2C6UmqQUsrP1q6vUuojR99bCEdJIRTlitb6BNYi4o+195fTU8BEpVQC1l+0ixw87ddYf5mHY51c8nOO90sAxtvOFYO1uC7Lcfwg1muRx2xDizXz5D0EPAh8gXVYcAAwQGud7mC2vDoppRKxzoxdj3UCz81a6wjb8TlYh2LPYp0B+kee138LNLdlXaK13g98grWXFgW0ArZcY6aPgXFKqaq265I9sA7//mnLOQV4XWv98ZUXaK2nAC8Cb2Atwqex9kqXXON7C1EkpbU8mFcIIYT7kh6hEEIItyaFUAghhFuTQiiEEMKtSSEUQgjh1srcDauVK1fW9erVMzqGEEIIF7Jr165LWusqxXltmSuE9erVY+fOnUbHEEII4UKUUieLbmWfDI0KIYRwa1IIhRBCuDUphEIIIdyaFEIhhBBuTQqhEEIItyaFUAghhFuTQiiEEMKtSSEUQgjh1qQQCiGEcGtSCIUQQrg1KYRCCCHcmhRCIYQQbk0KoRBCCLfmtEKolPpOKXVBKbW3gONKKfW5UuqIUmqPUqq9s7IIIYQQBXHmY5hmA9OAOQUc7ws0tn3dAnxp+68QQohy6vjxGM6dSyQqKpHz5xMZNaotvr6e+dqdPRvPO+9syN6uWTOQt9/uavecW7eevq5MTiuEWuuNSql6hTS5B5ijtdbAH0qpCkqpGlrrc87KJIQQouRdvpzC4cPRREUlcf58Ik2bVuaOO+rabXvnnbM5fTo+e3tH44V41IrP1+7yYQ8Wf10tezukUQaRI+bna2dJt3Bgufm68hv5YN5aQM4yfsa2L18hVEqNA8YB1KlTp1TCCSGEO8vK0uzaFUlUVBJRUYlER6cwYUJnu23nzg3n+edDs7effLJDdiE8n3ae8MRw61dCOJcCKgMVs9v+d98iUHZ6dBeqAk9lb8ZkxvB15Ne52yQDbwGnfYr5U1oZWQiVnX3aXkOt9SxgFkCHDh3sthFCCFG0EydiOXDgIufPJxIVlUTXrvW49dYb7La97bbvyMzMyt5+9tmOdocxq1cPyLW95ugf9Pp7KuEJ4VzIuJC7cfD95CyEI73HcWfTqvnOeZYMJnIpe7umd03eavpVrjYzRs8g/O9wfAI9SSW1wJ+5KEYWwjNA7RzbNwCRBmURQogyKyUlg40bT2YPTWqteeWVLnbbzpixg48/3pq9PWnSXXYLocmkqFrVn8jIhOx9UVFJ1KtXgeiMaMITwrN7epujzwJX3+/w2UgOXw4DIMgcRJvANrQJsH5tutWbiIwkalYPonr1AMa2a88ttfK//2XfFGp9tT97OyTEh2G1WuRq0+njToy6OIoPPphJr14dHfvDssPIQrgMeEYp9T+sk2Ti5PqgEEJctWtXJAcOXMqeWPLgg61p06Z6vnZxcWn06TMve7tiRd8CC2G1av65ts+fTyzw/atXz10IH9g0jpNntnI27WzuhgEVoVFD/CpnUbmqL01b1OGp1ktoE9CGuj51UerqAOCYTwv9kXP9DOPG3ZRvf1xcHMHBwQC0atWKnTt35jp/cTitECqlFgBdgcpKqTNYR3I9AbTWM4EVwN3AEawjvY86K4sQQriK6OhkVq8+mt17q1TJl3/9y/61tylT/mD+/Ijs7RYtqtothFWq+GEyKbKyrFeOLl9OIT3dgpdX/kkkeYcxrxTCuMw49iTsuXo9LzGc8DrVQQVDxUQISWIrOyEtBj+TH60DWl/t6d3UhlYjWxHoEVjsPxdH7N69mz59+vDee+8xZswYgOsuguDcWaP3F3FcA0876/2FEKI0rV17jH/+iebcuUTOnUvgjTfuoG7dCvnanTwZx8iRP2dvt2pVtcBCmLf3FhVlv/dmNpuoXNmPCxeSsvdduJDEDTcE5WvboGEInbtVx1wxlfQKMRxrvJz6WyZwIvVE/hM/A3V86tiGNW+hTcA42gS2oaFvQ0yqdNdj2bx5M/379ycuLo7FixczevToEimCYOzQqBBCuLTIyAQ2bz7FuXMJnDuXSOPGFRk92v7aH++8s4FNm05lb48Y0dJuIby2oUn7vTd7BgxoQnJyBtWq+VO9egC+vh4kWZKISIzIdT0vIjWChNcTcr84FbxN3rT0b2kteraeXuuA1oR4hhT4nqVlxYoVDB06lJSUFIYOHcoPP/xQYkUQpBAKIdzQ6tVHOX06jnPnrNfe3n+/O0FB3vna7dwZyYgRP2Vv9+3bqMBCWKNG7mHBc+cS7LarWjV3Ibx0KZnMzCw8PPL3sNq0qcbw4S2yi1unTvZnd2qt+b9pbW0Fbyc7E8P59lA4R1KOoO1Mxq/hVSPXBJY2AW1o4tcED5PrlYT58+fzyCOPkJmZyejRo/nqq68wm6/vvsG8XO+nFkKIYjh+PIY//zzL+fPW4taxYy2GDGlmt+1TTy3n6NGY7O2nn76ZoKAq+drl7ZGdO1dwj6xGDcfaenqaeeSRNgQEeGUXuCvX9vLq3bsRvXs3yrUv1ZLKvqR92fflhSeGsydxDzGZMfle76E8aObfLLvYtQ1sS+uA1lT1yn+7giuaPXs2jz32GFprJkyYwAcffFCiPcErpBAKUY6MH7+SS5eSiYtLIy0tk3nzhlCtWkC+dn/+eYaXXlqN1tbexC231OLTT/vYPefLL69m7drjWC/rwyef9KJ79wb52l24kES7dl9ltwsJ8WXfvqfytQP44os/mTx5c/b2M8905N//vt1u244dv+bMmasrj/z55xhq1w7O127lyiM8/fSK7O0xY9oVWAirVw/IVQjPnUukWTNHCqH9Xh5Aly51SEhIo0aNQGrUCOD22+2vrAIwe/agAo9dobXmfPr5XAUvPDGcQ8mHsGhLvvaVPCtd7eHZenvN/Jvhbcrf0y0rbr31VipVqsTLL7/MK6+84rT3kUIoRDkyb14Ely+nZG+npGTabRcTk8qWLVdX8wgMLPiX5bFjMezefT57Oza24BuXc061T0vL/8v6isTE9Fw9poSEtALbXriQlKutxWK/95S3R3b+fJLdduD4tbfq1QMYNKgpNWoEUKNGALVq5Z98csXQoc0ZOrR5gccLk5GVwYGkA7lnbCaEczHjYr62Jkw09Wuaq+C1CWhDTe+aTuktlTatdfbP0bRpUw4ePEilSpWc+p5SCIUoR4KDvXMVwiu9s7zy/r4sqJ21be7GBTU1m439JXwtvbdu3erh5+dJ9erWAteuXf5bEgC8vMz88suIkozJpfRLuYpdeGI4+5P2k6Ez8rUN9gi23qaQo6fXwr8Ffma/Es3kKjIzMxkzZgw33XQTzz77LIDTiyBIIRSiXAkOdmzNRUeLm7WtY+9tNhv7eNO6dSswZEgzqle3Xndr1KhigW2ffrojTzv55i2LtvBP8j+5hjXDE8OJTLO/gFZD34b5hjbz3oxenqWmpnLfffexdOlSFi9ezIgRI6hatXSuZarCPgm6og4dOuidO3caHUOIQsXHp3HyZCynTsWRkJDOTTfVoHHj/J9s09Iy+fTTP0hKSicxMZ2sLM3UqX3tnnP+/Ajefns96ekWBg1qyttvd6VChdyF75dfDpCUlEFwsDc+Ph506VLH7tqQMTEp7NtnHXZTCipU8KFFC/u/dI4diyE2NhWlrAW0Xr0K+d4XrIs0nzuXkP2LW6n8MymvSEhIIyEhPXs7IMDL7qxNsN47l3M4tGpVf7szLI0UlxmXu+AlhLM3aS+pWfmHkf3N/rTyb5VrWLNVgPNvRndl8fHxDBo0iHXr1hESEsLy5cvp1KnTNZ1DKbVLa92hOO8vPUIhHJSQkMbPPx/AYtFYLFkEBHhx//2t7LYdPHghv/9+PHt7+vS77RZCpRSvvbY2e9vDw8Rnn/Wx2wtITEzn8OHLgLWApqRk5CtIgwfbnxySV0iIL126OPYklwYNHLuPzGRShV5Dyykw0LvQ65I52ZvsY5QsncWxlGP5JrCcTD1pt/3Vm9Gv9vSMuBndlV26dIm+ffuyc+dOatSowerVq2nZsmWpZpBCKNzeH3+c4dChSxw7FsPRozF89lkfKlfOfw3m4sVkRo1amr1dv36FAgth3bq5ZzVaLFl223l5mfHwMGWv8J+ZmUV6ugVv7/z/NHMulzVz5i7mzNnDiy/eyoQJnR0uKsJxiZmJRCTluRk9MYJES/6JNa58M7orO336NL169eLgwYM0aNCAsLAwGjTIPyPZ2aQQinJNa83Fi8mkpWXanXIPMHr0Mvbvvzo775lnOtothHkngxQ0exGgXr3cK4oU1tbf35O4uKuzJpOSMooshADJyRn8+edZt7mG5Cxaa06lnso3geVoytEyfzO6q0tPTyc2NpZWrVoRGhpKjRo1DMkhf3OiXFq79hgTJqzhyJHLxMencf/9LZk//167bRs3rpirEB47FmP3sTR5J4MU1MsDaNSoIg0bhlC3bgUqV/ajceOCJ268/PJtZGVp/P098ff3wsfH/j/Lfv0ac/Dg03h5mfH0NBMQ4GX3Wp0o2JWb0Xcn7s51M3psZmy+tp7KM9fN6FeKXxWv/PcbiuJp2LAhv//+O9WrVyckxLjesxRCUSadPRvPH3+cYciQZnZ7RCaT4q+/rj7V68iRywWeK2+ROnYs/wodYJ3Q8dBDrTGbTZjNiooVfQs858iRrRg50v6waV5vvHGHQ+2Cg30cnhXq7rTWnEs/l2tYc0/ingJvRq/sWTnffXnN/JvhZfIyIH35tnHjRnbv3s348eMBaNbMsevaziSFUJQpTz75GytXHuHkyTgA/vnnGbuTUPLuO3z4cq4bdXPq1Kk2Q4fG0ahRCA0ahHDbbbXztQHrzMo5cwaXwE8hSlJ6Vnrum9Ftxe9SxqV8bU2YaObXLPfQZmAbanjVkCHmUvDbb78xbNgwUlNTad68OT169DA6EiCFULigrCyNyWT/l9KRIzHZRRBg8+ZTdgthzZqB+Pp6kJKSiZ+fJ3XrBpOcnIG/f/5P+EOGNCtwKS5X93fC30w+MZm0rIJXZimvNNZre4XdjJ53WLOFfwt8zQX35IXzzJs3j0ceeQSLxcK4cePo1q2b0ZGySSEUhktPt/Dvf68lKiqJf/6JplIlX1aseMBu2y5darNmzbHs7S1bTvPoo+3ytTOZFBs2jKJWrSBq1Agot5/2Z5yZwY8XfjQ6huEa+TbKN7RZx6dOuf17L2umTZuWvVLMa6+9xqRJk1zq70YKoTCcp6eJqVP/zL6FICDAq8DH0nTubL33zcvLTIcONWnRouCJCzffXMs5gV1IprauJfrMDc/Qo6JrDDOVpqpeVWnl34oAD9e511BcpbXm3Xff5a233gLg448/5uWXXzY4VX5SCEWp2LLllO3J3PknkCilqFrVP3vB5sTEdPbsiaJ9+/xTqW+7rTabNz/KTTfVLHB2pTtqH9iee6rcY3QMIXKJiYnh66+/xmQyMWvWLEaPHm10JLvkN4lwGq01GzacZOLEDaxbd4IKFXzo16+x3ZmP1ar553pywe7d5+0WQj8/z+xeoRDCtVWsWJGwsDAOHDjA4MGuO9FMCqFwmuTkDIYMWUhMjHW9xdjYVKZN287rr+e/XeCVVzqTnJxB9eoBtG9fw6WW1RJCOC4lJYVff/2V4cOHA9ZHKTVt2tTgVIWTBe+E0/j7e/HCC7fm2jdlinWB6bxGjGjJo4+2o2/fxlIEhSij4uPj6du3LyNGjGDWrFlGx3GY9AjFdSvo/jyAZ5+9hU8+2UZcXBq3dq2G50NbGPLPgFJOWH5FJEYYHUEIAC5evEifPn3466+/qFmzJp07dzY6ksOkEIpiS0+3MHduOB99tJXFi4fTsmX+x/hUqODDjBn9qFevAsurzeT9Ez9AwYu8iGKq5V3+Z8gK13Xq1Cl69erFoUOHaNSoEWFhYdSrV8/oWA6TQiiKZdGifbz4Yihnz1onuHz44RbmzrV/MfzKTNGlR6xT/R+r8RjDqw0vnaBuoLJnZdoHtjc6hnBTBw8epGfPnpw5c4Y2bdoQGhpKtWrVjI51TaQQimLx9DRlF0GABQsimDixK/XrF71wbhO/JvSu1NuJ6YQQpUFrzahRozhz5gydO3fmt99+o0KFCkW/0MXIZBmRT1aWZvfu83z++Z+5VnHJ6Z57mtKsWeXsbaUUmzefKq2IQggXoJRi3rx5jBo1itWrV5fJIghSCEUeq1YdoUmTL2jX7iuee24Vc+aE221nMilefbULvr4ejB/fkaNHx/PQQ21KOa0QwggHDhzI/r5hw4b897//xc8v/zM8ywophCKXOXPCOXr06mOINmw4WWDb++9vycmTzzN1al/q1LH/0FshRPkyZ84cWrVqxX/+8x+jo5QYuUbopuacm8N3kd/lewJ3xmhPPFfdQkaM9SkNp07FcctvvfGpkVrwyRwcET2WYn+YVQhRNkydOpXnn38egLi4uCJalx1SCN3U5BOTOZh80P7Bp8/DpKFw8xFof4ztaeEQm1xi713HR5ZIE6Is0Vrz1ltv8e677wIwZcoUXnjhBYNTlRwphG4q9YwvVIS5zedS2yf3g2h1O83pASnUaVzyzwu78ow4IUTZkJWVxfjx45k+fTomk4lvv/2WUaNGGR2rREkhdEPTp2/n5Mv94OvjdOzUkSZ+TfI36lj6uYQQruf1119n+vTpeHl5sXDhQgYNGmR0pBInk2Xc0MyZu9CpHjBlIFprLJYsoyMJIVzUE088QbNmzVi5cmW5LIIghdAtnTplu8j9dwOee3ALsbGFTIQRQridlJQUtLZOpKtbty4RERHcddddBqdyHimEbiYlJYP4+LTs7dAlpwkJ8TUwkRDClURFRXHbbbfx3nvvZe8zm80GJnI+uUZYzi2+sJhPTn2CRVsASL/gjTnodizx1tsjqtX0xWSy/+QIIYR7OXnyJD179uTw4cMkJyfzwgsvEBBQ/h+LJoWwnJt2ehrb4rZd3eED/LwJMsz4xFdiadNtBb5WCOE+9u/fT69evTh79ixt27YlNDTULYogSCEs97KwToSZceOMfE8oqOdTj2reZWuVeCFEydu+fTt333030dHR3H777fz6668EB7vPalFSCN1Ec//m3BJ8i9ExhBAuZvPmzfTt25fExET69evHjz/+iK+ve80bkMky5VhaWib/TLoRzlQ0OooQwkU1aNCAypUrM3LkSH755Re3K4IgPcJy7bXX1nL+l1qw9WEu3JQKRT8qUAjhZmrWrMm2bduoWrUqJpN79o3c86d2A//8E80XX2y3bkRV4OUhe7h4McnYUEIIlzBlyhRef/317O3q1au7bREE6RG6rH8f+TfLo5cX+/UnX7uFzMxa2dvJiZmkp1tKIpoQoozSWvPmm28yadIkAO69917at29fxKvKPymELuqjUx9l3/uXz/kK8GsHSPGCBF+4IRoeWZ+7zSNnIaMHbG4GwFsfdqJWrSDnhhZCuCyLxcIzzzzDzJkzMZvNfPfdd1IEbaQQuqA//zyD5bX7YNI8dnXchVnlXtUhYmcMDy3ckL3d5paKfN/xs9wn6QgMgb+3RbPux2iefvDOUkguhHBF6enpPPzwwyxcuBBvb28WLVrEwIEDjY7lMqQQuhitNaNGLYWDjeFsJdoEtslXCD2rXQSuFsKUGEWbQPuPNmrTC0b1cmZiIYQrS05OZujQoaxcuZLAwECWLVtG165djY7lUtz36qiLOn06noMHL1k3/q7P2bPx+dr4+3vm2r50qeQemiuEKF+SkpI4evQolStXZt26dVIE7ZAeoYvZsePs1Y3Qtrx6cS3z5w3N1aZyZT/ef/8u/P29CAnxoUoV/1JOKYQoK6pUqUJYWBjJyck0bdrU6DguSQqhi9m5M/LqxsEbqNI7f5Hz9/fitdduL8VUQoiy5Pjx4yxcuJBXXnkFpRR16tQxOpJLk0LoYrp3b0D4xQOs3BYOR6pz8801jY4khChD9u7dS69evTh37hyVKlVi7NixRkdyeVIIXUyPHg2YWmU13P8bZJoYeudbRkcSQpQRf/zxB3fffTcxMTHceeedjBgxwuhIZYJMlnFBV54M/WPbhfj4eBbRWgghYM2aNfTo0YOYmBgGDBjAypUrCQqSe4cdIYXQhfmYfYyOIIQoAxYvXky/fv1ISkrioYceYvHixW65eHZxSSEUQogyLDMzk4kTJ5Kens748eOZPXs2np4yknQt5BqhEEKUYR4eHqxYsYKffvqJ8ePHo5QyOlKZIz1CFzF16h8sX/4PGRmyMLYQonBaa5YsWZI9n6BWrVo899xzUgSLSQqhwbTWvP32ep5/PpT+/RdQvebHLH8nCy7IRW4hRH4Wi4UnnniCwYMH83//939GxykXpBAa7OefD/DOO1fXDb18KQ3WtAZPCzf63WhgMiGEq0lPT+f+++9n1qxZ+Pj4cMsttxgdqVyQQmiwQYOaMnJkq+xtb38F7y7ggWaDaOzX2MBkQghXkpSUxIABA/jxxx8JCgoiNDSU/v37Gx2rXJDJMgYzm018//0gMjOzWLXqCGPn+PBJwCmCzcFGRxNCuIjLly/Tv39/tm3bRpUqVQgNDaVdu3ZGxyo3pBC6AA8PEz/8MJijR2NY678Q/jE6kRDClYwfP55t27ZRp04dwsLCaNKkidGRyhUZGnURnp5mmjatbHQMIYQL+uSTTxg4cCBbtmyRIugEUghL0aFDl4iOlmcHCiGKdurUKbKysgCoVq0aS5cu5YYbbjA4VfkkhbCUnDkTT48ec7nttu84fjzGbpuFUQt55p9nSjmZEMLVbNu2jbZt2/LSSy9l3ysonMephVAp1UcpdUgpdUQp9aqd48FKqV+VUuFKqX1KqUedmccosbGp9O07jzNn4vnnn2g6dfqWXbsi87X76cJP2d/fFHRTaUYUQriI1atXZy+effz4cTIzM42OVO45rRAqpczAdKAv0By4XynVPE+zp4H9Wus2QFfgE6WUl7MyGWXy5E3s3XshezsqKon58yMKbP9V0694rOZjpRFNCOFCfvzxR/r3709ycjKjRo3ip59+knVDS4Eze4QdgSNa62Na63Tgf8A9edpoIFBZ1wUKAC4D5e7jz8SJ3bjvvpbZ24MGNeWjj3oW2D7EI6Q0YgkhXMjXX3/NiBEjyMjI4IUXXuDbb7/Fw0Mm9pcGZyLRqWUAACAASURBVP4p1wJO59g+A+RdBmEasAyIBAKBEVrrrLwnUkqNA8YB1KlTxylhncnb24N584ZQu3YQmzefYv78IZjNcnlWCGE1d+5cxo0bB8B7773Hv//9b1k3tBQ5sxDa+1vMe9W3N7AbuAtoCIQppTZpreNzvUjrWcAsgA4dOpTJK8cmk+Kjj3qSmpqJj498yhNCXHX33XfTqlUrnnzySZ588kmj47gdZ/5GPgPUzrF9A9aeX06PAh9o67SoI0qp40BTYLsTcxlKiqAQAqyLZwOYzWYqVarEzp078fIqd1MkygRn/lbeATRWStUHzgL3ASPztDkFdAc2KaWqATcCx5yYqdRkZmbh4WHi6YNPMy9qnkOvSbIkOTmVEMIVpKWl8cADD1ClShVmzJiBUkqKoIGcVgi11plKqWeAUMAMfKe13qeUesJ2fCbwLjBbKRWBdSj1Fa31JWdlKi0bN55kzJhlLF8+kgVRC4jLjHP4tYHmQFoHtHZiOiGEkRITExk8eDBr1qwhKCiICRMmUL9+faNjuTWnjtNprVcAK/Lsm5nj+0iglzMzlLafftrPfff9hMWi6dlzLln/8YeQGI7ddsyh2aC+Zl+8Td6lkFQIUdouX77M3XffzZ9//knVqlUJDQ2VIugC5IJVCdJaExjohcVinc9z8mQcpn8Nhi9mEuwRTAXPCgYnFEIYJTIykl69erFv3z7q1q1LWFgYjRvLo9ZcgRTCEqSUws8v982v3r0OkOKbYVAiIYQrOHHiBN26dePEiRM0b96c1atXU6tWLaNjCRu5mc1JlIJZs/rjM3KX0VGEEAYLCQmhQoUKdOzYkY0bN0oRdDHSIyxhFSv6ct99LRk9uh09ejTglQ1GJxJCGC04OJjQ0FB8fX0JDAw0Oo7IQwphMWRmZdJlVxf+PnEEVTkxf4Nx8AvAOkjLSivteEIIF7Bq1SqWLVvGtGnTMJlMVK1a1ehIogBSCIvhbNpZ/jy+D0a8DJXioelZaHUKhm6z2759YHuCPYJLOaUQwij/+9//eOihh8jMzKRr164MHz7c6EiiEFIIi+ugbYw/Ogi2BHFzxl1snPa73abeJm9ZN1AINzFz5kyeeuoptNa8/PLLDBs2zOhIoghSCIvrUO6L3bfeUhsfs49BYYQQRtNaM3nyZF5//XUAJk+ezCuvvCIfgssAKYTFleqF8spEp1v/CDt2lFlgQrirK72/KVOmoJTiyy+/5PHHHzc6lnCQFMLiemoVN4w/wJLAbWzffpZu3eoZnUgIYZCUlBQ2b96Mp6cnc+fOZcSIEUZHEtdACuF1UB6a9u1r0L59DaOjCCEM5Ofnx4oVK9izZw/dunUzOo64RnJDvQO01tyx6w7UWoVaq6i3tZ7RkYQQBktISODDDz/MfpxSpUqVpAiWUdIjdECiJZFNsZvy7b+70t0GpBFCGC06Opq+ffuyY8cO4uLieP/9942OJK6DFMJrEGAOIKFrAlprmQkmhJs6c+YMvXr14sCBA9SvX5/Ro0cbHUlcJxkavUYrVhymf/8FpKVlGh1FCFHKDh8+TJcuXThw4AAtW7Zk8+bNNGzY0OhY4jpJIbwGGctbMnDgAlasOMzDDy8hK0sbHUkIUUp2795Nly5dOHnyJLfeeisbNmygZs2aRscSJUAKoaNC25L2nz7ZzxpctGgf//rXaoNDCSFKy5tvvsmFCxfo1asXa9asoWLFikZHEiVECmEOaVlppFpS839lpUKnQ6g60dltlYIGDYp+4rwQonyYO3cur732GsuWLcPf39/oOKIEKa3L1vBehw4d9M6dO0v8vO8df483j71ZaBu/izUJeuFFYmNTmT9/CIMHNyvxHEII17F+/Xq6dOmCh4fMK3R1SqldWusOxXmt9Aht1sWsA8BDeeBt8rb7NbRVD1asGMnatQ9LERSinJs+fTp33XUXY8eOpax1GMS1kY85eaxqu4ruFbsbHUMIYRCtNZMmTeLNN60jRE2bNpXbpco5KYRCCGGTlZXFSy+9xGeffYbJZGLmzJmMHTvW6FjCyaQQCiEEkJmZyZgxY/j+++/x9PRk/vz5DB061OhYohRIISzElesCMiwiRPk3efJkvv/+e/z9/fnll1/o2bOn0ZFEKXH7yTIWbSE2I5YMnZHv2J49UVSq9BF33jmbZ59dwcKFew1IKIQoDc8//zx9+vRhzZo1UgTdjFv3CC3aQrvt7YhIjLB7PCLiAjExqWzceJKNG09y/HgsI0a0LOWUQghniY6OJjAwEC8vLwIDA1m5cqXRkYQB3LpHmJCZkF0Egz2CaenfkvaB7bOP79kTlat969bVSjWfEMJ5Tp8+TZcuXXjkkUeyH6Uk3JNb9wivCPYIJvbO2Hz7Dx2KzrXdqlXV0ookhHCiQ4cO0bNnT06fPo2npydxcXGyZJobk0JYiF9+GcHx4zFERFwgIiKKTp1qGx1JCHGd/vrrL/r06cPFixfp1KkTy5cvJyRElkt0Z1IIC2EyKRo2rEjDhhUZNKip0XGEENdpw4YNDBgwgISEBHr37s3ixYtl3VDh3tcIhRDuY+vWrfTp04eEhARGjBghi2eLbG7dI4y3xBsdQQhRStq2bUuHDh1o0aIF06dPx2w2Gx1JuAi3LYS/XvyVwRGDjY4hhHAyi8WC2WzGz8+P0NBQfH19ZZEMkYvbDo3+nfA3Fm3B3+zPqBqjjI4jhChhWmveeecdhg0bRmZmJgB+fn5SBEU+btsjvOLF2i8yseHEXPuysjRvv72eFi2q0KpVNZo0qYSHh9t+ZhCizMnKyuKFF17g888/x2QysXXrVu644w6jYwkX5faF0J4TJ2J5992N2ds1agQQGfmSgYmEEI7KyMjgscce44cffsDLy4sFCxZIERSFkkJoR94VZZo0qWRQEiHEtUhJSWH48OH89ttv+Pv7s3TpUrp3l+eLisJJIbQjIiJ3IZQVZYRwffHx8QwYMICNGzdSsWJFVq5cSceOHY2OJcoAKYR23HFHXV56qRN79kQREXFB1hgVogzw8vLCw8ODmjVrEhYWRvPmzY2OJMoIKYR23HlnPe68s172dlaWNi6MEMIhPj4+LFmyhMuXL1O3bl2j44gyRKZCOsBkkunWQriigwcPMmbMGNLT0wEIDAyUIiiumfQIhRBl0s6dO+nbty+XLl2iXr16vPHGG0ZHEmWU9AiFEGXOunXr6NatG5cuXeLuu+/mxRdfNDqSKMOkEAohypSlS5fSt29fEhMTGTlyJEuWLMHPz8/oWKIMk0KYR3R0MlrL5BghXNGcOXO49957SUtL46mnnmLu3Ll4enoaHUuUceX6GmGqJZWTqSftHruUccnu/ubNZ5CRYaFVq2q0bl2VSZO6ExTk7cyYQggHaK1ZtGgRFouFN954g4kTJ8q6oaJElOtCeNOOm9iftL/QNjn/IUVFJXLhQhIAGzeeZPv2s3z6aR+nZhRCOEYpxaJFi1i6dCn333+/0XFEOVKuC+GVItjEr4nd44HmQAZVGZS9HRFxIdfx5s2ryGLbQhgoKyuLGTNmMGbMGHx8fPDz85MiKEpcuS6EVxzqdMihdhcuJOHv70lSUgaArCgjhIEyMjJ45JFHWLBgAVu2bGHBggVGRxLllFsUQkeNHNmK++5ryYkTsezZE0X16gFGRxLCLSUnJzNs2DBWrFhBQEAA48aNMzqSKMccKoRKKS+gjtb6iJPzGM5kUjRoEEKDBiFGRxHCLcXGxjJgwAA2b95MpUqVWLlyJTfffLPRsUQ5VuQFMKVUPyACCLNtt1VK/eLsYEII9xMVFUW3bt3YvHkztWrVYtOmTVIEhdM5MhNkInALEAugtd4NNHJmKCGEe5o8eTK7d++mcePGbNmyhWbNmhkdSbgBR4ZGM7TWsXnu15E7zoUQJe6DDz7AYrHw5ptvUrWqPAdUlA5HeoQHlFLDAZNSqr5S6jPgDyfnEkK4ifDwcJKTkwHro5S++OILKYKiVDlSCJ8BbgKygJ+BVOA5Z4YywuTJm3j99bUsXLiX/fsvkpmZZXQkIcq9NWvW0LlzZ4YNG0ZGRobRcYSbcmRotLfW+hXglSs7lFJDsBbFcuPbb//m6NGY7O0dO8bSoUNNAxMJUb79/PPP3H///aSnpxMSIrO0hXEc6RHae8jX6yUdxEiJiem5iqBS1lVlhBDO8d133zFs2DDS09N59tlnmTNnjiyeLQxTYI9QKdUb6APUUkpNyXEoCOswabmxb1/updUaNaqIn5/8oxTCGT755BNefvllAN566y3eeustWTxbGKqwodELwF6s1wT35difALzqzFDFkaWzCE8MJz0r/Zpf26BBCN9/P4iIiCj27LlA/foVnJBQCLFo0aLsIjh16lTGjx9vcCIhQBX17D2llI/WOrWU8hSpQ4cOeufOnfn2v3H0DSadmJRvv0KR1b1cdWCFKLPS09MZNmwYQ4cO5aGHHjI6jihHlFK7tNYdivNaRybL1FJKTQKaAz5Xdmqt7T/SwSDHUo4B0MC3AZU9K2fv71NJHqMkhJHS09NJT08nICAALy8vlixZIkOhwqU4UghnA+8B/wH6Ao/iwtcI323wLiOrjzQ6hhAC6+LZ9957LxkZGSxfvhxvb28pgsLlODJr1E9rHQqgtT6qtX4D6ObIyZVSfZRSh5RSR5RSdq8rKqW6KqV2K6X2KaU2OB5dCOHKYmJi6NmzJ6tWrSI8PJwTJ04YHUkIuxzpEaYp60e4o0qpJ4CzQJHLPiilzMB0oCdwBtihlFqmtd6fo00FYAbQR2t9Sikly0kIUQ6cP3+e3r17s2fPHmrXrk1YWBg33nij0bGEsMuRHuELQAAwHugMjAUec+B1HYEjWutjWut04H/APXnajAR+1lqfAtBaX6CUFTVZSAhxbY4fP06XLl3Ys2cPTZs2ZcuWLVIEhUsrshBqrf/UWidorU9prR/SWg8ETjpw7lrA6RzbZ2z7cmoChCil1iuldimlHrZ3IqXUOKXUTqXUzosXL+Y6lmJJYVPMJqLSoxyIlN/Chfvw8XmPKlU+pmHDz5kwIaxY5xFCwMmTJ+ncuTNHjx7lpptuYuPGjdSuXdvoWEIUqtChUaXUzViL12at9SWlVAusS63dBdxQxLntXRHP2/3ywLqOaXfAF9imlPpDa/1PrhdpPQuYBdbbJ3Iee3Dfg/x88epqb2ZlLiJWbvHxaaSlWUhLS+bSpWQuX065ptcLIa6qVasWHTt2JC4ujqVLlxIUFGR0JCGKVNjKMpOBe4Fw4A3bw3ifAz4EnnDg3GeAnB8FbwAi7bS5pLVOApKUUhuBNsA/OOhU6ikA2ga0pZFfI3pU7OHoSwFrIcwpKMj7ml4vhLBeYlBK4eHhwf/+9z/A+iQJIcqCwnqE9wBttNYpSqmKWItYG631IQfPvQNorJSqj3WCzX1YrwnmtBSYppTyALywPgD402v5Aa6Y1WwWNwdd+5OsExKkEApxPRYvXsyXX37JsmXL8PPzkwIoypzCCmGq1joFQGt9WSl18BqKIFrrTKXUM0AoYAa+01rvs808RWs9U2t9QCm1CtiD9d7Eb7TWe4v90xTD22935dVXuxAfn0Z8fJoUQiGuwTfffMPjjz9OVlYW8+fPZ8yYMUZHEuKaFVYIGyilrlx8U0C9HNtorYcUdXKt9QpgRZ59M/Nsfwx87HDiEqaUwtfXE19fT6pVCzAqhhBlzkcffcQrr1ifzjZx4kRGjx5tcCIhiqewQnhvnu1pzgwihCgbtNa89tprfPjhhwBMmzaNp59+2uBUQhRfgYVQa722NIMU14WMUr/1UAi3ZbFYePLJJ/n666/x8PDg+++/Z+RIWdJQlG2OrCzj0q7MGjU5tDaAEOJ6xcfH4+Pjw08//US/fv2MjiPEdSvzhdBLeZGu02nm38zoKEKUe2azmTlz5rBv3z7atWtndBwhSoTD3SillEtPp7zWG+mvmDs3nHnz9vDrr4fYsOEE6emWEk4mRNl2+fJlnnzySRISEgDw8vKSIijKlSJ7hEqpjsC3QDBQRynVBhijtX7W2eFKw7PPriQu7uq9hNHRE6hY0dfAREK4jsjISHr37s3evXtJSUlh9uzZRkcSosQ50iP8HOgPRANorcNx8DFMrk5rnW9lmcBAL4PSCOFajh49SpcuXdi7dy9NmzblvffeMzqSEE7hSCE0aa3zLrJdLsYPk5IyyPnwCT8/Tzw9izfEKkR5EhERQZcuXTh+/DgdOnRg06ZN3HBDUcsLC1E2OTJZ5rRteFTbnjH4LNewFqiznEs7x/b47ViuoyZrrRk3rj3x8ekkJKRhNsvMUyG2bt1Kv379iI2N5a677mLJkiUEBgYaHUsIp3GkED6JdXi0DhAFrLHtM1S3v7pxKNm64psJE8ruwy4KFxjozVdfDSjpaEKUaT/88AOxsbEMGjSIBQsWyNqhotxzpBBmaq3vc3qSa3Qu7RwAfSv1pVfFXniZ5NqeECXh888/p2XLlowbNw4PjzJ/h5UQRXJkLHCHUmqFUuoRpZTLjY8saLmA5+s8b3QMIcq0RYsWERcXB4CHhwdPPfWUFEHhNhx5Qn1D4D2sD9CNUEotUUq5XA9RCHHttNZ88MEHjBgxggEDBpCZmWl0JCFKnUOzQ7TWW7XW44H2QDwwz6mphBBOp7VmwoQJvPbaayilGDlypPQChVty5Ib6AKwP6b0PaIb1Ybq3OTmXEMKJLBYLjz/+ON9++y0eHh7MnTuX++6TgR7hnhz5+LcX+BX4SGu9ycl5HBZvib/uc8ycuZNvv/2bwEAvgoK8GTmyFcOHtyiBdEK4rrS0NB544AEWL16Mr68vixcvpm/fvkbHEsIwjhTCBlrrLKcnuQZxmXHZ33uo4g/lHD8ew86dkdnbt9xS67pyCVEWzJo1i8WLFxMcHMzy5cvp3Lmz0ZGEMFSBVUQp9YnW+iVgsVJK5z3uyBPqnSVnIfQ3+xf7PHmXVwsKcul1xYUoEU899RSHDh1i7NixtGnTxug4QhiusO7UQtt/XfbJ9LW9a1/X6+Pj03NtBwZKIRTlU2RkJN7e3lSqVAmz2cy0aS77z1qIUlfYE+q3275tprXO9a9GKfUMUCaeYF+YyZO7M358R+Lj00hISOemm2oYHUmIEnfkyBF69uxJtWrVWLNmDQEBAUZHEsKlOHKB7THy9wpH29lX5tSpE0ydOsFGxxDCacLDw+nduzdRUVFUrVqV9PT0ol8khJsp7BrhCKy3TNRXSv2c41AgEOvsYEKI67Nlyxb69etHXFwc3bt3Z8mSJdIbFMKOwnqE27E+g/AGYHqO/QnA384MVZSzaWeNfHshXN7KlSu59957SUlJYciQIcyfPx9vb7kGLoQ9hV0jPA4cx/q0CZfy+MHHAcjQGQYnEcL17Nq1i4EDB5KZmcno0aOZOXOmrBgjRCEKGxrdoLW+UykVA+S8fUIBWmtd0enpCmDR1mcQvlDnBaMiCOGy2rVrxwMPPEDVqlX58MMPUeraH1EmhDsp7GNiN9t/K5dGkOLoV6lfsV9rsWTxxx9nCAz0JijI+lWxom8JphOi9GitSUpKIiAgAJPJxHfffYfJJA+aFsIRhQ2NXllNpjYQqbVOV0p1AVoDP2BdfLvMOnEili5d/pu9XamSL5cuTTAwkRDFo7Xm5Zdf5vfff2f9+vUEBwdLERTiGjjyr2UJoJVSDYE5WBfenu/UVKVgx47IXNutWlUzKIkQxXflOuCUKVPYt28f27dvL/pFQohcHCmEWVrrDGAI8JnW+lmgzC/KuWNH7pmnHTvWNCiJEMWTmprKsGHD+O9//4ufnx+//vorPXv2NDqWEGWOI1PJMpVSw4CHgEG2fZ7Oi1S0/Un7r/sct99el+joFHbsiOTAgYt07Fjma7twIwkJCQwaNIjff/+dChUqsHz5cm67TZ6OJkRxOLqyzFNYH8N0TClVH1jg3FgFS8+6ujKGj8mn2OcZNKgpgwY1BSAhIQ0PD7mmIsqGxMREunfvzo4dO6hevTqhoaG0bt3a6FhClFlFFkKt9V6l1HigkVKqKXBEaz3J+dHsyyQz+/uGfg1L5Jyy2LYoS/z9/Wnfvj3R0dGEhYXRoEEDoyMJUaY58oT624G5wFms9xBWV0o9pLXe4uxwhWkb0NbItxfCMEoppk+fTkxMDJUru+zdTUKUGY6MB34K3K217qy1vg3oB0x1biwhRE5///03d911F9HR0QCYzWYpgkKUEEcKoZfWOnt2itb6AODlvEhCiJw2bdpE165dWbduHZMnTzY6jhDljiOTZf5SSn2FdXgU4AEMXnT7ehw+HE1amoUWLarI0lPC5S1fvpyhQ4dm3yoxaZJhl+eFKLcc6RE+ARwFJgCvAMeAx50ZqjCpltTrev2UKdto1epLGjb8nOefX8X+/RdLKJkQJWvevHkMGjSI1NRUxo4dy4IFC+QJEkI4QaGFUCnVCugD/KK1Hqi1HqC1/lhrfX3V6DqcSj1V7NdmZWmWLfsHgOPHY5k69U9OnJBHKwrXM23aNB588EEyMzN59dVX+eqrrzCbzUbHEqJcKrAQKqX+jXV5tQeAMKXUY6WWqhBXhjPfbvD2Nb/2r7/OERmZkL3t7+/JXXfVL6loQpSYY8eOAfDhhx8yefJkGcYXwokK6xE+ALTWWg8DbgaeLJ1Ijrkl6JZrfo3Wmn79GuPtbf1k3bt3I3x85DltwvX85z//Yd26dUyYIAvBC+FshVWBNK11EoDW+qJSqswvvXLzzbX47beRJCWlExZ2jMqV/YyOJARgXTz7//7v/3j++eepWrUqJpOJrl27Gh1LCLdQWCFsoJT62fa9Ahrm2EZrPcSpyZzI398re3k1IYyWmprKiBEjWLZsGZs3b2bDhg0yFCpEKSqsEN6bZ3uaM4MI4Y7i4+O55557WL9+PSEhIXz88cdSBIUoZYU9mHdtaQYRwt1cvHiRvn37smvXLmrWrMnq1atp0aKF0bGEcDsyU0QIA5w6dYpevXpx6NAhGjZsSFhYGPXrywxmIYxQ5ifAOOLs2XiSktKLbihEKVmwYAGHDh2idevWbN68WYqgEAZyuEeolPLWWqc5M4yz/OtfYfzyy0F69GjAwIFNGDKkGZUqyYxRYZwJEybg6enJo48+SkhIiNFxhHBrRfYIlVIdlVIRwGHbdhul1BdOT1ZCMjIsrFhxmNTUTH777R/GjfuNAwcuGR1LuKHNmzcTGRkJWBeGePHFF6UICuECHBka/RzoD0QDaK3DgW7ODFWSNm06RVzc1Y5s5cp+dOp0g4GJhDtatmwZPXr0oFevXsTFxRkdRwiRgyOF0KS1Pplnn8UZYZwhNjaVunWDs7f792+C2ewWl0aFi5g7dy5DhgwhLS2N22+/nYCAAKMjCSFycOQa4WmlVEdAK6XMwLPAP86NVXKGDGnG4MFNiYi4wLJlh+jSpY7RkYQbmTp1Ks8//zwAr7/+Ou+++67cJyiEi3GkED6JdXi0DhAFrMHF1h0tilKK1q2r0bp1NaOjCDehteadd97hnXfeAeCTTz7hxRdfNDiVEMKeIguh1voCcF8pZBGi3AgNDeWdd97BZDLxzTff8OijjxodSQhRgCILoVLqa0Dn3a+1HueUREKUA7179+Zf//oXnTp1YvDgwUbHEUIUwpGh0TU5vvcBBgOnnRNHiLIrJSWFmJgYatasiVKKjz76yOhIQggHODI0ujDntlJqLhDmtEQlJDk5Az8/T6NjCDcRFxfHgAEDiIqKYtOmTVStWtXoSEIIBxXnPoL6QN2SDlLShg//kWbNpvPKK2Fs2XIKiyXL6EiinIqKiqJr165s2rSJpKQkLl++bHQkIcQ1cOQaYQxXrxGagMvAq84MVZhMnVlkm9TUTNauPU5qaiYHD17io4+2Eh7+hMwaFSXu5MmT9OzZk8OHD9OoUSPCwsKoV6+e0bGEENeg0EKorDc8tQHO2nZlaa3zTZwxgq/Zt8BjW7eeJjX1asGsXTuIVq1kqEqUrAMHDtCrVy/OnDlD27ZtWbVqFdWqyYctIcqaQodGbUXvF621xfblEkUQINgjuMBjERFRubZ79GggNzGLEhUVFcXtt9/OmTNn6NKlC+vWrZMiKEQZ5cis0e1KqfZa67+cnsZBVTyrFHr8uedu5f77W7F+/QnWrj1G//5NSimZcBfVqlVj7Nix7Nmzhx9//BE/P3maiRBllSqok6eU8tBaZ9qePNEMOAokAQprZ7F96cXMketGpat8XYULd1ww4u2Fm0tLS8Pb2xuwrh5jsVjw8JDnWwthNKXULq11h+K8trCh0e22/w4CbgTuBoYBQ23/FcKtzJ49m1atWuV6lJIUQSHKvsIKoQLQWh+191VK+YRwCZ9++imPPvoohw8fZsmSJUbHEUKUoMI+zlZRShW4SrDWekpRJ1dK9QGmAmbgG631BwW0uxn4Axihtf6pqPMKUVq01rz55ptMmjQJsBbEp556yuBUQoiSVFghNAMB2HqG18r2yKbpQE/gDLBDKbVMa73fTrsPgVBHz30x42JxIglxTbKysnjmmWf48ssvMZvNfPfddzz88MNGxxJClLDCCuE5rfXE6zh3R+CI1voYgFLqf8A9wP487Z4FFgM3O3riGl417O5fseIwCxfuo3v3+nTvXp9atYKKFVyIrKwsHnzwQRYsWIC3tzeLFi1i4MCBRscSQjhBkdcIr0Mtci/Ofca27+obKFUL6yLeMws7kVJqnFJqp1JqJ0Bz/+Z22y1depA5c8J55JEl3HDDp3zwwebryS/cmMlkomnTpgQGBrJq1SopgkKUY4UVwu7XeW57hTTvvRqfAa9orS2FnUhrPUtr3aGoqbG//34i13a7dtUdiCmEfW+++SZ79+6la9euRkcRQjhRgYVQa329KwefAWrn2L4BiMzTpgPwP6XUCay3ZcxQSg0qzpudOhXHkSNXI3t6mujSpU5xTiXcVFRUFAMGBdnKzQAAIABJREFUDODUqVOA9faIOnXk/yEhyjtn3gS1A2islKqPda3S+4CRORtoretf+V4pNRv4TWtdrLnp1asHsH79I6xde5y1a4/j4+OBv79X8dMLt3LixAl69uzJkSNHUEqxbNkyoyMJIUqJ0wqhbVWaZ7DOBjUD32mt9ymlnrAdL/S64LXy8jJz5531uPPOekyc2I2sLJdZFlW4uP3799OzZ08iIyNp164d33zzjdGRhBClyKnLYmitVwAr8uyzWwC11qNK8r1NJllkWxRt+/bt9O3bl8uXL3PHHXewbNkygoMLXtBdCFH+FOfBvEKUC2vWrOGuu+7i8uXL9O/fn1WrVkkRFMINSSEUbis8PJykpCQefPBBfv75Z3x9C37GpRCi/JIVg4Xbeumll2jSpAn9+vXDZJLPhEK4qzL/rz8rS/PFF3/y99/nZIKMKNKMGTM4evTqmvEDBgyQIiiEmyvzPcK9ey8wfvwqAEJCfBg48EZmzy7WrYiiHNNa88Ybb/D+++/TsGFD9u7di4+Pj9GxhBAuoMwXwvXrT2R/HxOTyuXLKcaFES7JYrHw9NNP89VXX2E2m3n77belCAohspX5Qrhu3Ylc21271jMkh3BN6enpPPzwwyxcuBAfHx8WLVrEgAEDjI4lhHAhZb4Q9u/fGIANG04QE5NKt271DM0jXEdSUhL33nsvoaGhBAUF8euvv3LHHXcYHUsI4WLKfCEcPbo9o0e3x2LJYs+eKFq3rmZ0JOEili9fTmhoKFWqVGHVqlW0b9/e6EhCCBdU5gvhFWaziXbt7D+nULin4cOHc+7cOfr06cONN95odBwhhIsqN4VQCIDjx4+Tnp6eXfiee+45gxMJIVyd3EAlyo29e/fSuXNnevbsyenTp4t+gRBCIIVQlBN//PEHd9xxB+fOnaNhw4ayZqgQwmFSCEWZFxYWRvfu3YmJiWHgwIGsXLmSoKAgo2MJIcqIMnuNUGtN794/YDabCAjwIiDAi5kz+/1/e3ceV1WdPnD888UN3M2yUVxwQ2R1w3FHJZfcyiUtbVwmdxtbRts0K/VXtk1mmtaY2WLqZCFOpqFpidsomlvu44qSoiaCigL3+f1xr3dAIBCBw4Xn/Xrdl557z/LcLxee+z3ne74PpUq57FtSObBs2TIGDhxIUlISQ4YMYf78+RQvrp8BpVT2uexfjGPHfmfNmmPO5dKlS/DJJ70sjEjlt8OHDzNgwABsNhtPP/007777rs4bqpS6Yy6bCH/++WSa5ZYtq2sx3iLG29ubGTNmcOPGDSZNmoQx+vNXSt05l02EJ09exs3NOCtOtGtXy+KIVH4QEWJiYqhWrRoAEydOtDgipZSrc9nzSK+91oHff3+eVasG8eKLbejRw9vqkFQeS0lJYeTIkTRt2pRjx45lvYFSSmWDy/YIAcqXL0XXrvXo2rWe1aGoPHbjxg0ef/xxli1bhru7O//973+pU6eO1WEppQoBl06EqmhISEigT58+rFmzhvLly/Pdd9/Rtm1bq8NSShUSmghVgXbp0iW6d+/O1q1bqVKlCqtXr6Zx48ZWh6WUKkQ0EaoC68aNG7Rv3569e/dSq1Yt1qxZQ/369a0OSylVyLjsYBlV+JUqVYoRI0bQsGFDNm7cqElQKZUnjIhYHcMdMd5GfPoPYorf85QtW5Jy5UppVfpCJjk5Oc3sMNevX8fDw8PCiJRSBZ0xZoeINMvRti6XCOu7CUdfcS6XKVOChISXLIxI5abNmzczdOhQVqxYgY+Pj9XhKKVcxN0kQtc7NWpLO3tI2bIlLQpE5bbVq1fzwAMPcOTIET744AOrw1FKFRGulwiTi6VZrFRJT5kVBkuXLqVXr15cv36dYcOG8f7771sdklKqiHC9UaPFbNQeeZLW13py9Ogl6te/x+qI1F366KOPGDNmDCLC3//+d95++22dN1QplW9cLxGWSKHOqFN80aS31ZGoXDBjxgxefPFFAF5//XVeeOEFTYJKqXzleolQFSqVK1fGzc2NOXPmMHr0aKvDUUoVQZoIlaVGjBhB27ZtdYSoUsoyrjdYRrm0Gzdu8MQTT7B3717nc5oElVJW0h6hyjfx8fH07t2bH3/8kS1btrB3716KFSuW9YZKKZWHNBGqfHHx4kW6devGtm3buP/++1m8eLEmQaVUgeB6p0b/ez9b+zehY8fPGDPmO6ujUdlw5swZ2rVrx7Zt2/Dy8mLjxo0EBQVZHZZSSgGu2CNMcePqf8uw/r8nuHDhmtXRqCwcOXKETp06cfLkSfz8/Pjhhx/w9PS0OiyllHJyvR5hKl5eFa0OQWVh586dnDx5kj//+c9s2LBBk6BSqsBxvR5hKnXrVrI6BJWFAQMGUKpUKR544AHKli1rdThKKZWO6yXCur/RfOpOJpR4nTp1NBEWRKtWraJKlSo0bdoUgIcfftjiiJRSKnOulwiLCeV8rvJIEz+rI1EZWLx4MYMHD6ZixYrs2rVLT4UqpQo8l7xGeOjaIatDUBmYO3cugwYNIjk5mWHDhlGtWjWrQ1JKqSy5ZCJ86L6HrA5BpSIi/N///R9jx45FRJgxYwZvvfWWTp6tlHIJrndqFChhSlgdgnKw2WxMmDCB9957D2MM8+bNY+TIkVaHpZRS2eaSiVAVHFFRUcycOZMSJUrw5Zdf0r9/f6tDUkqpO+J6ifBaSc5EFWPrpWiaN/fEzU1Pv1mpefPmzJ8/H09PT7p06WJ1OEopdceMiFgdwx0xpprAKACSkl6meHGXvMzp0uLj4zl27JhOk6aUKjCMMTtEpFlOtnXpLFKsmPYG89uFCxfo2LEjHTp0SFNKSSmlXJXLJsLixd10VGI+O336NG3btiUqKopKlSpRpkwZq0NSSqm75nrXCD1uUtUnmbpl6lgdSZFy+PBhOnXqxKlTp/D39yciIoKqVataHZZSSt011+sR1rjIgCUJREYOszqSImPnzp20adOGU6dO0bJlSzZs2KBJUClVaLheIlT5Ki4ujk6dOhEbG0vnzp1Zs2YNlSrpHK9KqcJDE6H6QxUqVGDmzJkMGDCAFStW6HVBpVSho4lQZejChQvO///lL39h8eLFlCpVysKIlFIqb2giVOl88MEH1KtXj507dzqf0xG6SqnCyiUT4fmb560OoVASEV577TXGjx9PXFwcW7ZssTokpZTKc66XCM9W4vTrjZkzZ5vVkRQqNpuNp59+mldffRU3Nzfmz5/PuHHjrA5LKaXynOslwgR3IhdfJTxcaxLmlqSkJIYOHcqsWbMoWbIkX3/9NU888YTVYSmlVL5wvRvqHXSy7dwhIgwcOJBly5ZRpkwZli9fzgMPPGB1WEoplW9cr0fooIkwdxhj6N+/P/fddx8//vijJkGlVJHjetUnqpaWES+9xQDfboSG6jRrOSUiaUaCXrlyhfLly1sYkVJK5VzRqj5R/jot+5bRJHgXTp06RbNmzdKMCtUkqJQqqlwvEaq7cujQIdq0acPOnTt56aWXcLUzAkopldvyNBEaY7oaYw4ZY44aY17I4PVBxpg9jsdmY4xWes1DtybPPn36NK1btyYsLExvlFdKFXl5lgiNMcWAOcCDgC/wmDHG97bVjgMhIhIITAM+zqt4irqff/6Z9u3bc+HCBR588EEiIiKoWLGi1WEppZTl8rJH2Bw4KiLHROQmsAR4KPUKIrJZRH53LG4FqudhPEXWv//9b7p06UJ8fDyPPvooy5cvp3Tp0laHpZRSBUJeJkJP4HSq5WjHc5l5AliV0QvGmJHGmChjTBQ2w41rNm7eTMnFUAs3ESE5OZkxY8bw5ZdfUrJkSatDUkqpAiMvb6jP6OJThiMzjDEdsCfCNhm9LiIf4zhtakw1GVM/mp8GhLFkSb/cirVQ69WrF9u3b6dRo0Z6TVAppW6Tlz3CaKBGquXqwNnbVzLGBALzgYdE5GJ2d6431GdORJg2bRobNmxwPte4cWNNgkoplYG87BFuB+obY2oDZ4BHgYGpVzDG1AS+Bf4iIofvZOeaCDNms9l46qmnmD17NpUqVeL48eNUqFDB6rCUUqrAyrNEKCLJxpgngR+AYsACEfnVGDPa8fo8YApQGfjQ0VtJznJmACOUdDeUKlUsr0J3WUlJSQwbNoxFixZRsmRJFixYoElQKaWy4HpTrDUwsmD9AoZVG2Z1KAXK9evXeeSRR1i5ciVly5YlPDycjh07Wh2WUkrli7uZYs1lq0+o/4mLi6Nnz55ERkZSuXJlVq1aRXBwsNVhKaWUS9BEWAjs3r2brVu34unpSUREBL6+t89boJRSKjOaCAuBdu3a8c033xAQEICXl5fV4SillEvRROii9u/fz2+//ea8DtizZ0+LI1JKKdek1Sdc0Pbt22nXrh29evVi165dVoejlFIuzfUS4aUyRHx8hfXrj1sdiSXWrVtHx44duXjxIu3bt8fb29vqkJRSyqW5XiK8UJ4lr13mm28OWB1Jvlu+fDkPPvggCQkJDBw4kLCwMJ08Wyml7pLrJUKHojazzKeffkrfvn25efMmTz75JF988QUlSpSwOiyllHJ5mghdwNmzZxk7diw2m40pU6Ywa9Ys3Nxc9kenlFIFiuuNGq14ldDeZWndukbW6xYS1apVY8mSJZw4cYKnnnrK6nCUUqpQ0SnWCiibzcbevXsJCgqyOhSllCrw7maKNT2/VgDdvHmTQYMG0aJFizSllJRSSuU+1zs1Wshdu3aNfv36sWrVKsqVK4fNZrM6JKWUKtQ0ERYgly9fpkePHmzatIl7772X1atX07RpU6vDUkqpQk0TYQHx22+/0bVrV3bv3k2NGjWIiIjAx8fH6rCUUqrQ00RYANhsNmcS9Pb2Zs2aNdSsWdPqsJRSqkhwvcEyx+9jygMxhIcftDqSXOPm5sabb75JixYtiIyM1CSolFL5yPUSYVJxog8k8fvviVZHctfi4+Od/+/SpQubNm2iSpUqFkaklFJFj+slQgdXn1lm7dq1eHl5sWbNGudzOluMUkrlP5f9y2tcOA9+8803dO/enUuXLvHNN99YHY5SShVprpcIa8Uy/aeq9OrVwOpIcuSTTz6hf//+3Lx5k7/97W98+OGHVoeklFJFmuslwlLJVKtfggoV3K2O5I698847DB8+HJvNxquvvsr777+vp0OVUspievtEPpk2bRpTpkwBYNasWfztb3+zOCKllFKgiTDftG3blrJlyzJ37lwef/xxq8NRSinloIkwD4kIxjGqp3379hw/fpx7773X4qiUUkqlpheo8sjVq1fp2bMnK1eudD6nSVAppQoe10uE10pyaEsisbFXrY4kU5cuXaJTp06sXLmScePGcePGDatDUkoplQnXS4TRlXmz33k2bDhpdSQZiomJISQkhC1btlCzZk0iIiIoVaqU1WEppZTKhOslQgdTAO+oP3bsGG3atGHfvn34+PiwceNGvL29rQ5LKaXUH3DZwTIFbYq1vXv30qVLF2JiYmjWrBmrVq3Sa4IuICkpiejoaBITXX/uWqWKAnd3d6pXr06JEiVybZ+ulwg9buIdWIrKlT2sjiSN+Ph4Ll++TIcOHQgPD6dcuXJWh6SyITo6mnLlyuHl5VUgzzIopf5HRLh48SLR0dHUrl071/breomwxkVe+PZ+2larZXUkabRq1Yqff/6ZgIAA3N1db9aboioxMVGToFIuwhhD5cqViY2NzdX9ul4iLECWLVuGMYa+ffsCEBwcbHFEKic0CSrlOvLi91UTYQ7985//ZPTo0RQvXpw9e/bQoIFrTgKulFJFncuOGrXSm2++yciRI7HZbEyZMkVHhqq7UqxYMRo1aoS/vz89e/bk8uXLztd+/fVXOnbsiLe3N/Xr12fatGmIiPP1VatW0axZMxo2bIiPjw8TJkyw4i3kyGOPPUZgYCDvvfdettYvW7ZsnsRx8OBBWrZsSalSpXjnnXcyXU9E6NixI1euXMmTOHLDjh07CAgIoF69eowfPz7NZ+WWmzdvMmzYMAICAggKCuKnn35yvjZp0iRq1KiRrq1nz57Np59+mtfhW0dEXOqBN7LgzAKxgs1mk+eee04AMcbIhx9+aEkcKvfs37/f6hCkTJkyzv8PHjxYpk+fLiIi165dkzp16sgPP/wgIiJXr16Vrl27yuzZs0VEZO/evVKnTh05cOCAiIgkJSXJnDlzcjW2pKSkXN3fLTExMVKzZs072iZ1O+Wmc+fOybZt2+Sll16St99+O9P1vvvuO3n66afvaN/Jycl3G94dCQ4Ols2bN4vNZpOuXbvK999/n26d2bNny9ChQ0XE/t6bNGkiKSkpIiKyZcsWOXv2bLq2vnr1qjRq1Cjv30A2ZfR7C0RJDvOK9gizKSUlhZEjR/LWW29RvHhxFi1axJgxY6wOS+Ui86PJk8edaNmyJWfOnAHgq6++onXr1nTu3BmA0qVLM3v2bGbMmAHAW2+9xaRJk/Dx8QGgePHijB07Nt0+ExISnD2AwMBAZzHo1N/6ly1bxtChQwEYOnQozz77LB06dGDixIl4eXml6aXWq1ePc+fOERsbS9++fQkODiY4OJhNmzalO3ZiYqLz2I0bN2b9+vUAdO7cmfPnz9OoUSMiIyPTbHPu3Dl69+5NUFAQQUFBbN68Od37CQ0NpUmTJgQEBBAeHg7YpzXs3r07QUFB+Pv7s3TpUgBeeOEFfH19CQwMzLDHXKVKFYKDg7Mcjr9o0SIeeugh5/LDDz9M06ZN8fPz4+OPP3Y+X7ZsWaZMmcKf//xntmzZwo4dOwgJCaFp06bOW6zAfnklODiYoKAg+vbty7Vr1/7w+FmJiYnhypUrtGzZEmMMgwcPZvny5enW279/P6Ghoc73XrFiRaKiogBo0aIFVatWTbdN6dKl8fLyYtu2bXcVY0HletcIYyry8ZMXaPbaOQIC7s+3wx49epQlS5bg4eHBsmXL6NatW74dWxUNKSkp/PjjjzzxxBOA/bRo06ZN06xTt25dEhISuHLlCvv27ePvf/97lvudNm0aFSpUYO/evQD8/vvvWW5z+PBh1q5dS7FixbDZbISFhTFs2DD+85//4OXlxf3338/AgQN55plnaNOmDadOnaJLly4cOHAgzX7mzJkD2O+zPXjwIJ07d+bw4cOsWLGCHj16sGvXrnTHHj9+PCEhIYSFhZGSkkJCQkKa193d3QkLC6N8+fJcuHCBFi1a0KtXL1avXk21atWc8/vGxcVx6dIlwsLCOHjwIMaYNAn9Tm3atImPPvrIubxgwQLuuecerl+/TnBwMH379qVy5cpcvXoVf39/pk6dSlJSEiEhIYSHh3PfffexdOlSJk2axIIFC+jTpw8jRowAYPLkyXzyySfpyrOtX7+eZ555Jl0spUuXTvcF4cyZM1SvXt25XL16deeXqtSCgoIIDw/n0Ucf5fTp0+zYsYPTp0/TvHnzP3z/zZo1IzIyMsv1XJHrJcJ4D7aGXePc2KsEBOTfYRs0aMCKFSsoUaIEbdq0yb8Dq3wjoemvp+SH69ev06hRI06cOEHTpk3p1KmTPZ5U1Utudycj59auXcuSJUucy5UqVcpym0ceeYRixYoBMGDAAKZOncqwYcNYsmQJAwYMcO53//79zm2uXLlCfHx8mntoN27c6Pzj7uPjQ61atTh8+DDly5fP9Njr1q3j888/B+zXTytUqJDmdRHhpZdeYsOGDbi5uXHmzBnOnTtHQEAAEyZM4Pnnn6dHjx60bduW5ORk3N3dGT58ON27d6dHjx5ZvvfMXLp0Kc17mzVrFmFhYQCcPn2aI0eOULlyZYoVK+YcSX7o0CH27dvn/JmmpKQ4e1z79u1j8uTJXL58mYSEBLp06ZLumB06dMjwy0JGJIPrgRl9Tv76179y4MABmjVrRq1atWjVqhXFi2edCqpUqcLBgwezFYurcb1E6JAfI94vXbrE1q1bnb2/Dh065P1BVZHj4eHBrl27iIuLo0ePHsyZM4fx48fj5+fHhg0b0qx77NgxypYtS7ly5fDz82PHjh0EBQX94f4zS6ipn7t9Zp0yZco4/9+yZUuOHj1KbGwsy5cvZ/LkyQDYbDa2bNmCh0fmk1tk9Mf5bi1atIjY2Fh27NhBiRIl8PLyIjExEW9vb3bs2MH333/Piy++SOfOnZkyZQrbtm3jxx9/ZMmSJcyePZt169bl6LjFixfHZrPh5ubGTz/9xNq1a9myZQulS5emffv2zjZ0d3d3fokQEfz8/NiyZUu6/Q0dOpTly5cTFBTEwoUL0wxaueVOeoTVq1cnOjrauRwdHU21atUyfB+pByi1atWK+vXrZ/n+ExMT//Bn7cpc9hphXt/7dfbsWUJCQujVqxc//PBDnh5LKYAKFSowa9Ys3nnnHZKSkhg0aBAbN25k7dq1gL3nOH78eJ577jkAJk6cyOuvv87hw4cBe2L6xz/+kW6/nTt3Zvbs2c7lW6dG77//fg4cOOA89ZkZYwy9e/fm2WefpWHDhlSuXDnD/WbUc2nXrh2LFi0C7KdbT506leWtRqGhocydOxew96BuH6UZFxdHlSpVKFGiBOvXr+fkSfsE/GfPnqV06dI8/vjjTJgwgZ07d5KQkEBcXBzdunVj5syZ2e5dZaRBgwYcO3bMGUOlSpUoXbo0Bw8eZOvWrZluExsb60yESUlJ/Prrr4B9NqqqVauSlJTkbKPb3eoR3v64PQkCVK1alXLlyrF161ZEhM8//zzNNc1brl27xtWr9uo9a9asoXjx4vj6+mb5/g8fPoy/v3+W67mknI6yserBnzxkxKwPJCYm/s6HGmXTkSNHpHbt2gKIr6+vREdH59mxlLUK2qhREZEePXrI559/LiIie/bskZCQEPH29pa6devKq6++Kjabzbnuv//9b2nSpIn4+PhIw4YNZcKECen2Hx8fL4MHDxY/Pz8JDAyUb775RkREvv76a6lTp46EhITIuHHjZMiQISIiMmTIEPn666/T7GP79u0CyMKFC53PxcbGSv/+/SUgIEAaNmwoo0aNSnfs69evy5AhQ8Tf318aNWok69atExGR48ePi5+fX4bt8dtvv0mvXr3E399fgoKCZPPmzWnaKTY2Vlq0aCFNmzaVJ554Qnx8fOT48eOyevVqCQgIkKCgIGnWrJls375dzp49K8HBwRIQECD+/v5p4r8lJiZGPD09pVy5clKhQgXx9PSUuLi4dOtNnTpV/vnPf4qISGJionTt2lUCAgKkX79+EhISIuvXr08T5y2//PKLtG3bVgIDA8XX11c+/vhjERH58MMPxcvLS0JCQuTJJ590tv/d2L59u/j5+UmdOnVk3Lhxzs9KeHi4vPzyyyJib3tvb2/x8fGR0NBQOXHihHP7iRMniqenpxhjxNPTU1555RXna40bN5bY2Ni7jjE35PaoUSN5cOoiL5kGRhasX8CwasPyZP979uyhc+fOnDt3jubNm/P99987vwGrwufAgQM0bNjQ6jCUC4iJiWHw4MGsWbPG6lDy3S+//MI//vEPvvjiC6tDATL+vTXG7BCRZjnZn8ueGs0LmzZtol27dpw7d47Q0FDWrl2rSVApBdhPPY4YMaJA31CfVy5cuMC0adOsDiPPuOxgmdyWmJhI//79iYuLo0+fPnz11VdaUFcplUb//v2tDsESt0a9FlbaI3Rwd3fnX//6F2PHjmXp0qWaBJVSqogo8j3CQ4cOOUextW7dmtatW1sckVJKqfzkej1CmyHxqo2UFNtd7UZEeP311/Hz8+Pbb7/NpeCUUkq5GtdLhEf/xFjvaKKizuZ4FyLCxIkTmTRpEjabjQsXLuRigEoppVyJ6yVCh5zeUJ+cnMzw4cN59913KV68OIsXL2bkyJG5HJ1SKj8U9hJWv/zyC8OHD7c6jD/0xhtvUK9ePRo0aJDp5CO7d++mZcuWBAQE0LNnT+fI24sXL9KhQwfKli3Lk08+mWabBx54IFvz4uaKnN6AaNUDqgq8Ktu23flN7tevX5fevXsLIB4eHrJq1ao73ocqXG6/MRdeTfPIzEcfRaVZb8SIFXkdao7ldymg/Dx+YS9h1a9fP9m1a1e+HvNO/PrrrxIYGCiJiYly7NgxqVOnToY/72bNmslPP/0kIiKffPKJTJ48WUREEhISJDIyUubOnSvjxo1Ls83ChQudP8/baRkmI5T0MBQrduehDx06lLCwMCpWrMiaNWvo2rVrHgSoVPadOHECHx8fhg8fjr+/P4MGDWLt2rW0bt2a+vXrO8vebNu2jVatWtG4cWNatWrFoUOHAPsUZBMmTHCWWPrggw8A8PLyYurUqbRp04avv/6aXbt20aJFCwIDA+ndu3em37QzKi00d+5c57RuAAsXLnROpP3ll1/SvHlzGjVqxKhRo0hJSQHSlyKaOnUqwcHB+Pv7M3LkSGfPbPv27QQGBtKyZUsmTpzonMIrJSWFiRMnEhwcTGBgYJqqD5kpbCWs4uPj2bNnj3Mu2cw+AwsXLuSRRx6hZ8+ezvf79ttvO9vulVdece4zs9JROXWrikWpUqWoXbs29erVy7BU06FDh2jXrh1gvxXjVjuWKVOGNm3a4O7unm6bXr16sXjx4ruOMVtymkGteuCNzD8zP8NvCVnZvn271K9fX3bv3p2j7VXhY3WP8Pjx41KsWDHZs2ePpKSkSJMmTWTYsGFis9lk+fLl8tBDD4mISFxcnPPb/po1a6RPnz4iYp+mq0+fPs7XLl68KCIitWrVkjfffNN5nICAAOc38pdfflmeeuqpDOO5tf21a9fEz89PLly4IOfPn5e6des61+natatERkbK/v37pUePHnLz5k0RERkzZox89tlnIiICyNKlS9PtV0Tk8ccflxUr7O3l5+cnmzZtEhGR559/3jnt2kcffSTTpk0TEft0Zk2bNpVjx46li/dWjzA5OVn69evnPMvzzDPPyMyZM9OtX7FiRYmLi5PGjRtnq6f13HOF9NfYAAAPLElEQVTPpWmrS5cupTmuiH2qutTT03Xv3t3ZKxo/frwsWGAvJL5161YJDQ0VEZHHHntMIiMjRUTk5MmT4uPjk+7Y69atc/6cRTL/DHz66afi6enpbOMffvhBRowYITabTVJSUqR79+7y888/i0jGP9/bPf300xIUFJTu8cYbb6Rbd9y4cfLFF184l//617+mm55PRKRly5ayfPlyERF59913pWzZsmle//TTT9P1CEVE6tWrl2GMud0jdMnbJ+4pfk+2101MTHR+22jWrBn79+/PVskRpfJL7dq1CXDUFPPz8yM0NBRjDAEBAZw4cQKwT/I8ZMgQjhw5gjGGpKQkwF4KafTo0c7P9D33/O9341a5pLi4OC5fvkxISAgAQ4YM4ZFHHskwloxKC7Vo0YI6deqwdetW6tevz6FDh2jdujVz5sxhx44dBAcHA/ZJwatUqQKQphQR2KsovPXWW1y7do1Lly7h5+dH27ZtiY+Pp1WrVgAMHDiQ7777DoCIiAj27NnDsmXLnO/hyJEj1K5dO028hbmEVUxMDPfdd59zObPPANh7Wbd+9hEREURERNC4cWPA3qs9cuQI7dq1y7R0VGqpK1NkRTKYojOj9l2wYAHjx49n6tSp9OrVi5IlS2Zr/1WqVOHs2bN5PsOXS2aEmu41s7XekSNH6NKlC9OnT2fgwIEAmgTVHxJ5JeuVgJEjmzJyZNOsV8yG1JM3uLm5OZfd3NxITk4G4OWXX6ZDhw6EhYVx4sQJ2rdv74g38z/4qUspZeT06dP07NkTgNGjR+Pj45NpaaEBAwbwr3/9Cx8fH3r37o0xBhFhyJAhvPHGG+n2nboUUWJiImPHjiUqKooaNWrw6quvkpiYmOEf0VtEhA8++CDDGn2pFeYSVh4eHmn2ndln4PZjiggvvvgio0aNSrO/PyodldozzzzD+vXr0z3/6KOP8sILL6R5rnr16pw+fdq5nFnpJx8fHyIiIgB7FYtbxZOzkl+ln1zvGmE27dq1izZt2nD8+HHmzZuHzXZ39x0qZaW4uDg8PT0B+zWhWzp37sy8efOcCfPSpUvptq1QoQKVKlUiMjISgC+++IKQkBBq1KjhLOszevToPywt1KdPH5YvX87ixYudvZrQ0FCWLVvG+fPnnce+VRIptVt/bO+9914SEhKcvbxKlSo5ywYBaXpeXbp0Ye7cuc5ez+HDh52lgzJSGEtYNWzYkKNHjzqXM/sM3K5Lly4sWLCAhIQEwF65/vz589kuHfXee+9lWPrp9iQI9ut4S5Ys4caNGxw/fpwjR45kWMH+1mfEZrMxffp0Ro8enWn8t4gIv/32G15eXlmue7cKZSKMjIwkJCSE8+fP06lTJ77//nvc3ArlW1VFxHPPPceLL75I69atnQNSAIYPH07NmjUJDAwkKCiIr776KsPtP/vsMyZOnEhgYCC7du1iypQp6dbp2rUrycnJBAYG8vLLL9OiRQvna5UqVcLX15eTJ086/9D5+voyffp0OnfuTGBgIJ06dSImJibdfitWrMiIESMICAjg4Ycfdp5KBfjkk08YOXIkLVu2RESc1eiHDx+Or68vTZo0wd/fn1GjRjmTfWYaN25MUFAQS5YswcPDg/DwcKZPn06DBg0ICAggODjYOUQ/MDCQmTNn8thjj9GwYUP8/f0zjH3y5Mn8/vvv+Pv7ExQU5OwpzZgxgx49etCxY0dnxfnMDBgwgC+//NL5BQLsp6CjoqIIDAzE19eXefPmpdvOx8eHuLg44uPjgcw/A7fr3LkzAwcOdN6u0K9fP+Lj4//w55tTfn5+9O/fH19fX7p27cqcOXOcZwKGDx9OVFQUAIsXL8bb2xsfHx+qVavGsGH/qx7k5eXFs88+y8KFC6levbrzlPGOHTto0aJFvpzFc8kyTFHbo2haPuPTUitXrqRfv34kJibSr18/vvzyS503VGVKyzBZKyEhwTkCc8aMGcTExPD+++9bHFXB8d5771GuXLkCfy9hXnjqqafo1asXoaGh6V7TMkx/YNmyZTz88MMkJiYyfPhwlixZoklQqQJs5cqVzhviIyMjndfQlN2YMWOK7N8wf3//DJNgXihUPcI9e/bQrl07Ro0axYwZM3I8+4wqOrRHqJTrye0eYaEaQhkYGMi+ffuoXr261aEoF/JHIy+VUgVLXnTeXPrUqM1m49lnn2XBggXO5zQJqjvh7u7OxYsX8+SXSymVu0SEixcvZjgTzd1w2R7hrcmzP/vsMzw8POjWrRt/+tOfrA5LuZjq1asTHR1NbGys1aEopbLB3d091zs8LpkIbyTeoN/gfoSHh1O6dGnCwsI0CaocKVGiRLrZSpRSRUuenho1xnQ1xhwyxhw1xqS7G9PYzXK8vscY0yTLnabAU/2eIjw8nEqVKrF27VrnRLNKKaXUncqzHqExphgwB+gERAPbjTErRGR/qtUeBOo7Hn8G5jr+zVw0RP03iqpVqxIREeGcrV4ppZTKibzsETYHjorIMRG5CSwBHrptnYeAzx2Th28FKhpj/niahiTw9PJk48aNmgSVUkrdtby8RugJnE61HE363l5G63gCaeY6MsaMBG6Vkb9x5sSZfXXr1s3daAu/e4ELVgfhgrTdck7bLme03XKmQU43zMtEmNGNWbePUc/OOojIx8DHAMaYqJzeNFmUabvljLZbzmnb5Yy2W84YY6Jyum1enhqNBmqkWq4OnM3BOkoppVSeyctEuB2ob4ypbYwpCTwKrLhtnRXAYMfo0RZAnIiknwJeKaWUyiN5dmpURJKNMU8CPwDFgAUi8qsxZrTj9XnA90A34ChwDRiW2f5S+TiPQi7stN1yRtst57TtckbbLWdy3G4uN+m2UkoplZtceq5RpZRS6m5pIlRKKVWkFdhEmCfTsxUB2Wi3QY722mOM2WyMCbIizoImq3ZLtV6wMSbFGNMvP+MrqLLTbsaY9saYXcaYX40xP+d3jAVRNn5PKxhj/m2M2e1ot+yMnyj0jDELjDHnjTH7Mnk9Z3lBRArcA/vgmv8CdYCSwG7A97Z1ugGrsN+L2AL4j9VxW/3IZru1Aio5/v+gtlv22i3VeuuwD/LqZ3XcVj+y+XmrCOwHajqWq1gdt9WPbLbbS8Cbjv/fB1wCSlodu9UPoB3QBNiXyes5ygsFtUeYN9OzFX5ZtpuIbBaR3x2LW7Hfu1nUZefzBvA34BvgfH4GV4Blp90GAt+KyCkAEdG2y167CVDO2CtGl8WeCJPzN8yCR0Q2YG+LzOQoLxTURJjZ1Gt3uk5Rc6dt8gT2b09FXZbtZozxBHoD8/IxroIuO583b6CSMeYnY8wOY8zgfIuu4MpOu80GGmKfYGQv8JSI2PInPJeWo7xQUOsR5tr0bEVMttvEGNMBeyJsk6cRuYbstNtM4HkRSbF/SVdkr92KA02BUMAD2GKM2Soih/M6uAIsO+3WBdgFdATqAmuMMZEiciWvg3NxOcoLBTUR6vRsOZOtNjHGBALzgQdF5GI+xVaQZafdmgFLHEnwXqCbMSZZRJbnT4gFUnZ/Ty+IyFXgqjFmAxAEFOVEmJ12GwbMEPuFr6PGmOOAD7Atf0J0WTnKCwX11KhOz5YzWbabMaYm8C3wlyL+rTy1LNtNRGqLiJeIeAHLgLFFPAlC9n5Pw4G2xpjixpjS2CvQHMjnOAua7LTbKey9aIwx92OvrHAsX6N0TTnKCwWyRyh5Nz1boZbNdpsCVAY+dPRukqWIz3SfzXZTt8lOu4nIAWPMamAPYAPmi0iGQ9+Limx+3qYBC40xe7Gf7nteRIp8aSZjzGKgPXCvMSYaeAUoAXeXF3SKNaWUUkVaQT01qpRSSuULTYRKKaWKNE2ESimlijRNhEoppYo0TYRKKaWKNE2EqshzVJPYlerh9QfremU28/0dHvMnR/WB3caYTcaYBjnYx+hbU5YZY4YaY6qlem2+McY3l+PcboxplI1tnnbcM6iUS9BEqBRcF5FGqR4n8um4g0QkCPgMePtON3bcp/e5Y3EoUC3Va8NFZH+uRPm/OD8ke3E+DWgiVC5DE6FSGXD0/CKNMTsdj1YZrONnjNnm6EXuMcbUdzz/eKrnPzLGFMvicBuAeo5tQ40xvxhj9jpqr5VyPD/DGLPfcZx3HM+9aoyZYOy1EZsBixzH9HD05JoZY8YYY95KFfNQY8wHOYxzC6kmMDbGzDXGRBl7vbzXHM+Nx56Q1xtj1jue62yM2eJox6+NMWWzOI5S+UoToVLgkeq0aJjjufNAJxFpAgwAZmWw3WjgfRFphD0RRRtjGjrWb+14PgUYlMXxewJ7jTHuwEJggIgEYJ/5aYwx5h7slS/8RCQQmJ56YxFZBkRh77k1EpHrqV5eBvRJtTwAWJrDOLsCqaeVm+SYlSgQCDHGBIrILOxzO3YQkQ7GmHuBycADjraMAp7N4jhK5asCOcWaUvnsuiMZpFYCmO24JpaCvZzQ7bYAk4wx1bHX3DtijAnFXm1hu2MKOw8yr1+4yBhzHTiBvdZhA+B4qjlgPwPGYS/JkwjMN8asBL7L7hsTkVhjzDHHvItHHMfY5NjvncRZBvt0YKkrfvc3xozE/nekKuCLfSq11Fo4nt/kOE5J7O2mVIGhiVCpjD0DnMNeKcENeyJKQ0S+Msb8B+gO/GCMGY59XsjPROTFbBxjkIhE3VowxlTOaCXH3JTNsU/C/CjwJPbyPNm1FOgPHATCRESMPStlO07sVdRnAHOAPsaY2sAEIFhEfjfGLATcM9jWAGtE5LE7iFepfKWnRpXKWAUgxlEM9S/Ye0NpGGPqAMccpwNXYD9F+CPQzxhTxbHOPcaYWtk85kHAyxhTz7H8F+BnxzW1CiLyPfaBKBmN3IwHymWy32+Bh4HHsCdF7jROEUnCfoqzheO0anngKhBn7NURHswklq1A61vvyRhT2hiTUe9aKctoIlQqYx8CQ4wxW7GfFr2awToDgH3GmF3Ya8V97hipORmIMMbsAdZgP22YJRFJxD5b/teOqgM2YB72pPKdY38/Y++t3m4hMO/WYJnb9vs7sB+oJSLbHM/dcZyOa4/vAhNEZDfwC/ArsAD76dZbPgZWGWPWi0gs9hGtix3H2Yq9rZQqMLT6hFJKqSJNe4RKKaWKNE2ESimlijRNhEoppYo0TYRKKaWKNE2ESimlijRNhEoppYo0TYRKKaWKtP8Hy7XG+oB7jBIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "skplt.metrics.plot_roc(y_valid[:,1], y_predProb, title=\"Validation Data ROC\",\n",
    "                      figsize=(7,7),\n",
    "                      plot_micro=False,\n",
    "                      classes_to_plot=1)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unbalanced Target Labels\n",
    "\n",
    "You can see that this MLP has difficulty with unbalanced labels. Here's something to try;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A UDU: Train the MLP By Weighting Observations\n",
    "\n",
    "One of the ways that can help training on data like this is to weight observations' contributions to the loss function based on how frequent, or infrequent, they are.  The Keras [fit function](https://keras.io/models/model/#fit) has an option _class weight_ that can be defined by a dict that maps weights to cases.  It should look something like {0:wt0, 1:wt1}, where wt0 and wt1 are weights (float) to be used for labels 0 and 1, respectively. See if you can apply this kind of weighting of the loss function when retraining the MLP, above.\n",
    "\n",
    "One question is, what data should be used to calculate the weights?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Another UDU: See If you Can Improve the MLP \n",
    "\n",
    "Can you improve the MLP, above, by adding layers to it?  By changing the number of nodes per layer? By using different learning rates? Using different activation functions?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regularization by \"Dropout\"\n",
    "\n",
    "Several different methods for regularizing neural networks can be used. One of them consists of randomly removing, \"or dropping out,\" individual neurons during training.  This effectively sets the outputs of these neurons doing an training iteration.  It's thought that doing this causes neurons to be less specialized.\n",
    "\n",
    "Let's try applying drop-out to a hidden layer of a version of the MLP that's above, A two hidden layer MLP.  The drop-out will be between the 1<sup>st</sup> and the 2<sup>nd</sup> hidden layers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3L Network Specification With Dropout, p(Dropout=0.20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "# del mlp2\n",
    "keras.backend.clear_session()  # this resets\n",
    "mlp2 = keras.models.Sequential() #stacked layers \n",
    "mlp2.add(keras.layers.Dense(6,activation='relu',input_shape=(6,))) # six features per row in X\n",
    "mlp2.add(keras.layers.Dropout(0.2))\n",
    "mlp2.add(keras.layers.Dense(4,activation='relu'))\n",
    "mlp2.add(keras.layers.Dense(2,activation=\"softmax\"))  # output layer: two categories, normalized to get probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 6)                 42        \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 6)                 0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 4)                 28        \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 2)                 10        \n",
      "=================================================================\n",
      "Total params: 80\n",
      "Trainable params: 80\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "mlp2.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compiling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp2.compile(loss='categorical_crossentropy',\n",
    "           optimizer='sgd',\n",
    "           metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp2Training=mlp2.fit(X_train,y_train,epochs=50,verbose=0,\n",
    "                   validation_data=(X_test,y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation Using Validation Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Data: loss 0.068 accuracy 0.980\n"
     ]
    }
   ],
   "source": [
    "valEval2=mlp2.evaluate(X_valid,y_valid,verbose=0)\n",
    "print(\"Validation Data: loss {:1.3f} accuracy {:1.3f}\".format(valEval2[0],valEval2[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Confusion Again!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    2225\n",
       "1      12\n",
       "dtype: int64"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred2=mlp2.predict_classes(X_valid)\n",
    "pd.Series(y_pred2).value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2183,    2],\n",
       "       [  42,   10]])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(y_valid[:,1],y_pred2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Summary Based on Validation Data\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      1.00      0.99      2185\n",
      "           1       0.83      0.19      0.31        52\n",
      "\n",
      "    accuracy                           0.98      2237\n",
      "   macro avg       0.91      0.60      0.65      2237\n",
      "weighted avg       0.98      0.98      0.97      2237\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Classification Summary Based on Validation Data\\n\")\n",
    "print(classification_report(y_valid[:,1],y_pred2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predicted Probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predicted probabilities\n",
    "y_predProb2=mlp2.predict_proba(X_valid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ROC, AUC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "skplt.metrics.plot_roc(y_valid[:,1], y_predProb2, title=\"Validation Data ROC\",\n",
    "                      figsize=(7,7),\n",
    "                      plot_micro=False,\n",
    "                      classes_to_plot=1)\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Tweaking\" Dropout Regularization\n",
    "\n",
    "* Dropout can be applied to input layers.\n",
    "* It will be more beneficial when applied to larger, rather than smaller, networks.\n",
    "* Dropout rates that are smaller, e.g. < 0.50, will tend to provide more benefit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## UDU:  Try Additional Dropouts\n",
    "\n",
    "See if you can bump up the AUC of the above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving and Restoring A Model\n",
    "\n",
    "This can be handy if it takes a long time to train a model, or if you have a model you want to use again later."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# It turns out that some versions of keras have difficulty \n",
    "\n",
    "#Alternative: \n",
    "\n",
    "model_path = \"yourpath.hdf5\"  # it contains the architecture and the weights\n",
    "model = create_model(...)  # the same cond you used to create the model before training\n",
    "model.load_weights(model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp2.save('my_mlp2_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 6)                 42        \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 6)                 0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 4)                 28        \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 2)                 10        \n",
      "=================================================================\n",
      "Total params: 80\n",
      "Trainable params: 80\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "mlp2IsBack=keras.models.load_model('my_mlp2_model.h5')\n",
    "mlp2IsBack.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Early Stopping\n",
    "\n",
    "This is a regularization method based on the idea that a better model can be obtained by not _over-training_.  It can be observed that when using gradient ascent models it's possible to train a model so much that it's performance on held out validation data starts getting worse and worse.  In the following we're going to apply a simple procedure to find the \"best\" a priori specified MLP model by discovering the epoch of the model the provides the best results.  Note that early stopping can be used with all sorts of gradient descent methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sequential Layers\n",
    "keras.backend.clear_session()  # this resets\n",
    "mlp3 = keras.models.Sequential() #stacked layers\n",
    "# mlp3.add(keras.layers.InputLayer(input_shape=[6,]))  \n",
    "mlp3.add(keras.layers.Dense(4,activation='relu',input_shape=(6,)))  # six features per row in X\n",
    "mlp3.add(keras.layers.Dense(3,activation='relu'))\n",
    "mlp3.add(keras.layers.Dense(2,activation=\"softmax\"))  # output layer: two categories, normalized to get probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compiling the network\n",
    "\n",
    "mlp3.compile(loss='categorical_crossentropy',\n",
    "           optimizer='sgd',\n",
    "           metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Callbacks\n",
    "\n",
    "One way to do early stopping is to write out the results of training epochs to a file, and then use the file's contents to identify how much training provides the best results.  Alternatively, you can just save the best performing model.  Let's do that, here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint_cb=keras.callbacks.ModelCheckpoint('my_mlp3_model.h5',\n",
    "                        save_best_only=True)\n",
    "history=mlp3.fit(X_train,y_train,epochs=100,verbose=0,\n",
    "                validation_data=(X_valid,y_valid),\n",
    "                callbacks=[checkpoint_cb])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# This version should work if your Keras version is 2.2.3+\n",
    "# It will run until fit on test data doesn't improve\n",
    "\n",
    "early_stopping_cb=keras.callbacks.EarlyStopping(\n",
    "                patience=10,restore_best_weights=True)   # stop when criterion doesn't improve for 10 epochs\n",
    "\n",
    "history=mlp3.fit(X_train,y_train,epochs=500,verbose=0,\n",
    "                validation_data=(X_valid,y_valid),\n",
    "                callbacks=[checkpoint_cb,early_stopping_cb])  # save both best, and checkpoints up to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "bestModel=keras.models.load_model('my_mlp3_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best model loss, accuracy:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.06063314465781741, 0.9830129637907913]"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Best model loss, accuracy:\")\n",
    "bestModel.evaluate(X_valid,y_valid,verbose=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Different Answers Based on the Method: Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "val_loss    0.060633\n",
       "val_acc     0.983013\n",
       "loss        0.060706\n",
       "acc         0.982710\n",
       "Name: 99, dtype: float64"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(history.history).sort_values(by=[\"val_acc\"],ascending=False).iloc[0,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "val_loss    0.061551\n",
       "val_acc     0.983013\n",
       "loss        0.061554\n",
       "acc         0.979431\n",
       "Name: 94, dtype: float64"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "historyDF=pd.DataFrame(history.history)\n",
    "historyDF.iloc[historyDF.val_acc.idxmax(),:]"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}