pablonm3/digit_classification.ipynb

## digit_classification.ipynb
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# +98% accuracy on digit classification using DNNs with Keras lib and simple experiments to try to improve its accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## imports,  setup & utils functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mYou are using pip version 10.0.1, however version 19.2.3 is available.\r\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, MaxPooling2D\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras import regularizers\n",
    "from tensorflow.keras import optimizers\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.model_selection import train_test_split\n",
    "from matplotlib import pyplot as plt\n",
    "import datetime;\n",
    "%matplotlib inline \n",
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint\n",
    "import tensorflow as tf;\n",
    "# SETUP tensorboard to use it inside jp notebook:\n",
    "!pip install -q tf-nightly-2.0-preview\n",
    "# Load the TensorBoard notebook extension\n",
    "%load_ext tensorboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotAccuracyAndLoss(history, ephocs):\n",
    "    acc = history.history['accuracy']\n",
    "    val_acc = history.history['val_accuracy']\n",
    "\n",
    "    loss = history.history['loss']\n",
    "    val_loss = history.history['val_loss']\n",
    "    epochs_range = range(ephocs)\n",
    "\n",
    "    plt.figure(figsize=(8, 8))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(epochs_range, acc, label='Training Accuracy')\n",
    "    plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
    "    plt.legend(loc='best')\n",
    "    plt.title('Training and Validation Accuracy')\n",
    "    plt.xlabel('ephocs')\n",
    "\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(epochs_range, loss, label='Training Loss')\n",
    "    plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
    "    plt.legend(loc='best')\n",
    "    plt.title('Training and Validation Loss')\n",
    "    plt.xlabel('ephocs')\n",
    "    plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## fetch data & format datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "A0OYmcZxY9Iv"
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    from sklearn.datasets import fetch_openml\n",
    "    mnist = fetch_openml('mnist_784', version=1)\n",
    "    mnist.target = mnist.target.astype(np.int64)\n",
    "except ImportError:\n",
    "    from sklearn.datasets import fetch_mldata\n",
    "    mnist = fetch_mldata('MNIST original')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 42
    },
    "colab_type": "code",
    "id": "LVWd2RSpY-rd",
    "outputId": "c065624f-6e83-4b35-a98d-1f8d99aeb6d8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((70000, 784), (70000, 1))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = mnist.data\n",
    "y = np.reshape(mnist.target, (1,-1)).T\n",
    "X.shape, y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 42
    },
    "colab_type": "code",
    "id": "cNAOw8pKZBhA",
    "outputId": "aa8e664e-649f-41f3-c9da-90a754aec98e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((56000, 784), (56000, 1))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "X_test = X_test\n",
    "X_train = X_train\n",
    "y_train = y_train.reshape(y_train.shape[0],1)\n",
    "y_test = y_test.reshape(y_test.shape[0],1)\n",
    "m, n = X_train.shape\n",
    "X_train.shape, y_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 270
    },
    "colab_type": "code",
    "id": "jbGPyZaFZD8w",
    "outputId": "8a690463-ae6d-4484-c9f4-e3b8963241ef"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(X[0, :].reshape((28,28)), cmap=\"gray\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 270
    },
    "colab_type": "code",
    "id": "NWHXVRR0ZGbH",
    "outputId": "0eae28d6-5f6f-4067-fb4a-75b32d263932"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(X[1, :].reshape((28,28)), cmap=\"gray\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scale the images(just divide each pixel by 255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zVQqedqDZKHC"
   },
   "outputs": [],
   "source": [
    "scaler = StandardScaler()\n",
    "X_train_scaled = X_train / 255\n",
    "X_test_scaled = X_test / 255\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Have a look at how using the wrong scaler can screw up your data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Original image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAADbtJREFUeJzt3X+MFPUZx/HPo22N0hqhwIlAStuYBqLG6kVMShqUilZJTvlDxaRgqhwxvaQ1/tGLTaxJY0Ia26bxjybXlICG2jbxjFi1rYVa2oQY8IICWipt+HUiJwFFjIYCT/+4oT315jvn7szOHs/7lVxud56dmScLn5vZ/e7O19xdAOI5q+4GANSD8ANBEX4gKMIPBEX4gaAIPxAU4QeCIvxAUIQfCOpTrdyZmfFxQqBi7m5jeVxTR34zu8HMdprZLjPrbWZbAFrLGv1sv5mdLemfkq6TtF/SZklL3P3VxDoc+YGKteLIf5WkXe7+b3c/Luk3krqa2B6AFmom/NMl7Rtxf3+27EPMrNvMtpjZlib2BaBklb/h5+59kvokTvuBdtLMkX9Q0swR92dkywCMA82Ef7Oki83si2b2GUm3S1pXTlsAqtbwab+7nzCzHkl/lHS2pFXuvqO0zgBUquGhvoZ2xmt+oHIt+ZAPgPGL8ANBEX4gKMIPBEX4gaAIPxAU4QeCIvxAUIQfCIrwA0ERfiAowg8ERfiBoAg/EBThB4Ii/EBQhB8IivADQRF+ICjCDwRF+IGgCD8QFOEHgiL8QFCEHwiK8ANBEX4gKMIPBEX4gaAanqJbksxst6R3JZ2UdMLdO8toCuWZP39+sr5hw4Zk3Sw94evSpUuT9cceeyxZR32aCn/mGnc/VMJ2ALQQp/1AUM2G3yX9ycxeMrPuMhoC0BrNnvbPc/dBM5sq6Xkz+4e7bxz5gOyPAn8YgDbT1JHf3Qez30OSnpR01SiP6XP3Tt4MBNpLw+E3swlm9rnTtyUtlLS9rMYAVKuZ0/4OSU9mQ0GfkvRrd/9DKV0BqJy5e+t2Zta6nQUyZ86c3NrLL7+cXPess9Inf0Xj/CdPnkzWp06dmls7cuRIcl00xt3T/2gZhvqAoAg/EBThB4Ii/EBQhB8IivADQZXxrT4UmDBhQrJ+zz33JOu9vb3J+jnnnJNbKxrKKzI0NJSsT5kyJVlfsWJFbm3lypUN9YRycOQHgiL8QFCEHwiK8ANBEX4gKMIPBEX4gaD4Sm8LPPzww8n6vffeW9m+T506lazfd999yfrVV1+drN92223J+saNG3Nr11xzTXJdNIav9AJIIvxAUIQfCIrwA0ERfiAowg8ERfiBoPg+fwlmzJiRrN95552taWQURZfeHhwcTNa3bduWrBeN86N9ceQHgiL8QFCEHwiK8ANBEX4gKMIPBEX4gaAKx/nNbJWkRZKG3P2SbNkkSb+VNEvSbkm3unvY+ZYvvPDCZH3ixIlNbf/pp59O1hcsWJBbO++885LrLl68OFnfvn17so7xayxH/tWSbvjIsl5J6939Yknrs/sAxpHC8Lv7RkmHP7K4S9Ka7PYaSTeX3BeAijX6mr/D3Q9kt9+U1FFSPwBapOnP9ru7p67NZ2bdkrqb3Q+AcjV65D9oZtMkKfudO5uju/e5e6e7dza4LwAVaDT86yQty24vk/RUOe0AaJXC8JvZ45I2SfqKme03s7skrZR0nZm9Lukb2X0A40jha353X5JTyh9cRqn27duXrD/wwAO5taI5A4pceumlTa2P9sUn/ICgCD8QFOEHgiL8QFCEHwiK8ANBcenuErz11lvJ+tGjR5P1888/P1m/4447kvW5c+fm1mbPnp1cd9OmTcn6ypXNfYRj165dTa2P6nDkB4Ii/EBQhB8IivADQRF+ICjCDwRF+IGgGOcvwZ49e5L1np6eZH316tXJ+gUXXJCsP/vss7m1tWvXJtfdu3dvsj5lypRk3T33Cm6SpM2bNyfrqA9HfiAowg8ERfiBoAg/EBThB4Ii/EBQhB8IyorGaUvdWWJar8h6e9OTHD/00EMt6uTjzCxZL/r/M3ny5NzakSNhZ3WvlLun/9EyHPmBoAg/EBThB4Ii/EBQhB8IivADQRF+IKjCcX4zWyVpkaQhd78kW/agpOWSTl+w/n53z/9S+f+3xTh/A7q6upL1u+++O7d20003NbXvZsf5+/v7c2vLly9PrsvnABpT5jj/akk3jLL8Z+5+efZTGHwA7aUw/O6+UdLhFvQCoIWaec3fY2avmNkqM5tYWkcAWqLR8P9C0pclXS7pgKSf5D3QzLrNbIuZbWlwXwAq0FD43f2gu59091OSfinpqsRj+9y90907G20SQPkaCr+ZTRtx9xZJ28tpB0CrFF6628welzRf0mQz2y/ph5Lmm9nlklzSbkkrKuwRQAX4Pv8ZIDUWf9lllyXXHRgYaHjbUvE4f8obb7yRrF955ZXJ+tDQUMP7PpPxfX4ASYQfCIrwA0ERfiAowg8ERfiBoBjqO8Ode+65yfqxY8eS9aKhvqLhtqIpvlOeeeaZZH3JkiXJ+nvvvdfwvsczhvoAJBF+ICjCDwRF+IGgCD8QFOEHgiL8QFCM85/hpk+fnqzv3bs3WS8a57/ooouS9UceeSS3tnjx4uS6RYq+rrxjx46mtj9eMc4PIInwA0ERfiAowg8ERfiBoAg/EBThB4IqvG4/xreFCxdWuv233347WV+6dGlubd68ecl1p06dmqwvWrQoWY86zj9WHPmBoAg/EBThB4Ii/EBQhB8IivADQRF+IKjCcX4zmynpUUkdklxSn7v/3MwmSfqtpFmSdku61d2PVNcqGvHcc8/Vuv/3338/t3bixImmtj179uym1o9uLEf+E5Luc/c5kq6W9B0zmyOpV9J6d79Y0vrsPoBxojD87n7A3Qey2+9Kek3SdEldktZkD1sj6eaqmgRQvk/0mt/MZkn6qqQXJXW4+4Gs9KaGXxYAGCfG/Nl+M/uspCckfc/dj468tpu7e971+cysW1J3s40CKNeYjvxm9mkNB3+tu/dniw+a2bSsPk3SqDM2unufu3e6e2cZDQMoR2H4bfgQ/ytJr7n7T0eU1klalt1eJump8tsDUJWxnPZ/TdK3JG0zs63ZsvslrZT0OzO7S9IeSbdW0yKa8c4771S6/aIpwD/44IPK9r1z587Kth1BYfjd/e+S8q4DvqDcdgC0Cp/wA4Ii/EBQhB8IivADQRF+ICjCDwTFpbvPcMePH0/WN2zYkKwvWJAeze3v70/WX3jhhdza5MmTk+sWWbduXVPrR8eRHwiK8ANBEX4gKMIPBEX4gaAIPxAU4QeCMvdRr75Vzc5yLvWF+sydOzdZ37RpU7Je5f+fQ4cOJetXXHFFsj44OFhmO+OGu+d9Bf9DOPIDQRF+ICjCDwRF+IGgCD8QFOEHgiL8QFCM8yOpq6srWe/p6UnWr7322tza4cOHk+tef/31yfrAwECyHhXj/ACSCD8QFOEHgiL8QFCEHwiK8ANBEX4gqMJxfjObKelRSR2SXFKfu//czB6UtFzSW9lD73f3Zwu2xTg/ULGxjvOPJfzTJE1z9wEz+5yklyTdLOlWScfc/eGxNkX4geqNNfyFM/a4+wFJB7Lb75rZa5KmN9cegLp9otf8ZjZL0lclvZgt6jGzV8xslZlNzFmn28y2mNmWpjoFUKoxf7bfzD4r6a+SHnL3fjPrkHRIw+8D/EjDLw2+XbANTvuBipX2ml+SzOzTkn4v6Y/u/tNR6rMk/d7dLynYDuEHKlbaF3vMzCT9StJrI4OfvRF42i2Stn/SJgHUZyzv9s+T9DdJ2ySdyhbfL2mJpMs1fNq/W9KK7M3B1LY48gMVK/W0vyyEH6ge3+cHkET4gaAIPxAU4QeCIvxAUIQfCIrwA0ERfiAowg8ERfiBoAg/EBThB4Ii/EBQhB8IqvACniU7JGnPiPuTs2XtqF17a9e+JHprVJm9fWGsD2zp9/k/tnOzLe7eWVsDCe3aW7v2JdFbo+rqjdN+ICjCDwRVd/j7at5/Srv21q59SfTWqFp6q/U1P4D61H3kB1CTWsJvZjeY2U4z22VmvXX0kMfMdpvZNjPbWvcUY9k0aENmtn3Esklm9ryZvZ79HnWatJp6e9DMBrPnbquZ3VhTbzPN7C9m9qqZ7TCz72bLa33uEn3V8ry1/LTfzM6W9E9J10naL2mzpCXu/mpLG8lhZrsldbp77WPCZvZ1ScckPXp6NiQz+7Gkw+6+MvvDOdHdv98mvT2oTzhzc0W95c0sfadqfO7KnPG6DHUc+a+StMvd/+3uxyX9RlJXDX20PXffKOnwRxZ3SVqT3V6j4f88LZfTW1tw9wPuPpDdflfS6Zmla33uEn3Voo7wT5e0b8T9/WqvKb9d0p/M7CUz6667mVF0jJgZ6U1JHXU2M4rCmZtb6SMzS7fNc9fIjNdl4w2/j5vn7ldI+qak72Snt23Jh1+ztdNwzS8kfVnD07gdkPSTOpvJZpZ+QtL33P3oyFqdz90ofdXyvNUR/kFJM0fcn5EtawvuPpj9HpL0pIZfprSTg6cnSc1+D9Xcz/+4+0F3P+nupyT9UjU+d9nM0k9IWuvu/dni2p+70fqq63mrI/ybJV1sZl80s89Iul3Suhr6+Bgzm5C9ESMzmyBpodpv9uF1kpZlt5dJeqrGXj6kXWZuzptZWjU/d20347W7t/xH0o0afsf/X5J+UEcPOX19SdLL2c+OunuT9LiGTwP/o+H3Ru6S9HlJ6yW9LunPkia1UW+PaXg251c0HLRpNfU2T8On9K9I2pr93Fj3c5foq5bnjU/4AUHxhh8QFOEHgiL8QFCEHwiK8ANBEX4gKMIPBEX4gaD+C3b5cvhDn1LAAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(X_train[2, :].reshape((28,28)), cmap=\"gray\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Image scaled the right way(divide by 255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(X_train_scaled[2, :].reshape((28,28)), cmap=\"gray\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Image scaled the wrong way(StandardScaler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_train_wrong = scaler.fit_transform(X_train)\n",
    "plt.imshow(X_train_wrong[2, :].reshape((28,28)), cmap=\"gray\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Takeaway: don't use scikit learn standard scaler to scale your images(at least with the default parameters) since it will subtract the mean from every pixel of your image, and when we do this the image loses information. Dividing each pixel by 255 is much better!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## experiment 0: get the basics to work using 1 hidden layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 300)               235500    \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 300)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 10)                3010      \n",
      "=================================================================\n",
      "Total params: 238,510\n",
      "Trainable params: 238,510\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Sequential([\n",
    "    Dense(300, activation='relu', input_shape=(n,)\n",
    "         ),\n",
    "    Dropout(0.1),\n",
    "    Dense(10, activation='softmax')\n",
    "])\n",
    "#sgd = optimizers.SGD()\n",
    "model.compile(optimizer='adam',\n",
    "              loss='sparse_categorical_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0828 05:16:18.989288 140595318212416 callbacks.py:862] `period` argument is deprecated. Please use `save_freq` to specify the frequency in number of samples seen.\n",
      "W0828 05:16:19.014512 140595318212416 deprecation.py:323] From /home/ec2-user/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_core/python/ops/math_grad.py:1423: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "W0828 05:16:19.080047 140595318212416 deprecation.py:323] From /home/ec2-user/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/tensorflow_core/python/keras/optimizer_v2/optimizer_v2.py:468: BaseResourceVariable.constraint (from tensorflow.python.ops.resource_variable_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Apply a constraint manually following the optimizer update step.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 56000 samples, validate on 14000 samples\n",
      "Epoch 1/50\n",
      "56000/56000 - 3s - loss: 0.2497 - accuracy: 0.9281 - val_loss: 0.1485 - val_accuracy: 0.9576\n",
      "Epoch 2/50\n",
      "56000/56000 - 2s - loss: 0.1059 - accuracy: 0.9682 - val_loss: 0.0950 - val_accuracy: 0.9724\n",
      "Epoch 3/50\n",
      "56000/56000 - 2s - loss: 0.0706 - accuracy: 0.9788 - val_loss: 0.0839 - val_accuracy: 0.9751\n",
      "Epoch 4/50\n",
      "56000/56000 - 2s - loss: 0.0539 - accuracy: 0.9835 - val_loss: 0.0746 - val_accuracy: 0.9776\n",
      "Epoch 5/50\n",
      "56000/56000 - 2s - loss: 0.0424 - accuracy: 0.9871 - val_loss: 0.0857 - val_accuracy: 0.9752\n",
      "Epoch 6/50\n",
      "56000/56000 - 2s - loss: 0.0343 - accuracy: 0.9891 - val_loss: 0.0805 - val_accuracy: 0.9755\n",
      "Epoch 7/50\n",
      "56000/56000 - 2s - loss: 0.0279 - accuracy: 0.9913 - val_loss: 0.0776 - val_accuracy: 0.9776\n",
      "Epoch 8/50\n",
      "56000/56000 - 2s - loss: 0.0222 - accuracy: 0.9929 - val_loss: 0.0780 - val_accuracy: 0.9783\n",
      "Epoch 9/50\n",
      "56000/56000 - 2s - loss: 0.0188 - accuracy: 0.9939 - val_loss: 0.0786 - val_accuracy: 0.9792\n",
      "Epoch 10/50\n",
      "\n",
      "Epoch 00010: val_loss improved from inf to 0.08028, saving model to chapter10_exp0.h5\n",
      "56000/56000 - 3s - loss: 0.0182 - accuracy: 0.9936 - val_loss: 0.0803 - val_accuracy: 0.9784\n",
      "Epoch 11/50\n",
      "56000/56000 - 2s - loss: 0.0150 - accuracy: 0.9951 - val_loss: 0.0868 - val_accuracy: 0.9788\n",
      "Epoch 12/50\n",
      "56000/56000 - 2s - loss: 0.0140 - accuracy: 0.9951 - val_loss: 0.0854 - val_accuracy: 0.9777\n",
      "Epoch 13/50\n",
      "56000/56000 - 2s - loss: 0.0124 - accuracy: 0.9959 - val_loss: 0.0781 - val_accuracy: 0.9806\n",
      "Epoch 14/50\n",
      "56000/56000 - 2s - loss: 0.0113 - accuracy: 0.9962 - val_loss: 0.0864 - val_accuracy: 0.9795\n",
      "Epoch 15/50\n",
      "56000/56000 - 2s - loss: 0.0121 - accuracy: 0.9956 - val_loss: 0.0871 - val_accuracy: 0.9796\n",
      "Epoch 16/50\n",
      "56000/56000 - 2s - loss: 0.0093 - accuracy: 0.9967 - val_loss: 0.0927 - val_accuracy: 0.9804\n",
      "Epoch 17/50\n",
      "56000/56000 - 2s - loss: 0.0102 - accuracy: 0.9965 - val_loss: 0.0874 - val_accuracy: 0.9795\n",
      "Epoch 18/50\n",
      "56000/56000 - 2s - loss: 0.0085 - accuracy: 0.9975 - val_loss: 0.0880 - val_accuracy: 0.9803\n",
      "Epoch 19/50\n",
      "56000/56000 - 2s - loss: 0.0099 - accuracy: 0.9964 - val_loss: 0.0949 - val_accuracy: 0.9795\n",
      "Epoch 20/50\n",
      "\n",
      "Epoch 00020: val_loss did not improve from 0.08028\n",
      "56000/56000 - 2s - loss: 0.0082 - accuracy: 0.9973 - val_loss: 0.0926 - val_accuracy: 0.9791\n",
      "Epoch 21/50\n",
      "56000/56000 - 2s - loss: 0.0075 - accuracy: 0.9975 - val_loss: 0.0883 - val_accuracy: 0.9816\n",
      "Epoch 22/50\n",
      "56000/56000 - 2s - loss: 0.0070 - accuracy: 0.9976 - val_loss: 0.0970 - val_accuracy: 0.9797\n",
      "Epoch 23/50\n",
      "56000/56000 - 2s - loss: 0.0062 - accuracy: 0.9983 - val_loss: 0.0996 - val_accuracy: 0.9801\n",
      "Epoch 24/50\n",
      "56000/56000 - 2s - loss: 0.0083 - accuracy: 0.9971 - val_loss: 0.1036 - val_accuracy: 0.9798\n",
      "Epoch 25/50\n",
      "56000/56000 - 2s - loss: 0.0075 - accuracy: 0.9975 - val_loss: 0.1029 - val_accuracy: 0.9796\n",
      "Epoch 26/50\n",
      "56000/56000 - 2s - loss: 0.0075 - accuracy: 0.9976 - val_loss: 0.0975 - val_accuracy: 0.9802\n",
      "Epoch 27/50\n",
      "56000/56000 - 2s - loss: 0.0059 - accuracy: 0.9981 - val_loss: 0.0996 - val_accuracy: 0.9801\n",
      "Epoch 28/50\n",
      "56000/56000 - 2s - loss: 0.0064 - accuracy: 0.9980 - val_loss: 0.1081 - val_accuracy: 0.9799\n",
      "Epoch 29/50\n",
      "56000/56000 - 2s - loss: 0.0074 - accuracy: 0.9975 - val_loss: 0.0946 - val_accuracy: 0.9815\n",
      "Epoch 30/50\n",
      "\n",
      "Epoch 00030: val_loss did not improve from 0.08028\n",
      "56000/56000 - 2s - loss: 0.0063 - accuracy: 0.9978 - val_loss: 0.1029 - val_accuracy: 0.9806\n",
      "Epoch 31/50\n",
      "56000/56000 - 2s - loss: 0.0061 - accuracy: 0.9979 - val_loss: 0.1074 - val_accuracy: 0.9794\n",
      "Epoch 32/50\n",
      "56000/56000 - 2s - loss: 0.0053 - accuracy: 0.9983 - val_loss: 0.1141 - val_accuracy: 0.9790\n",
      "Epoch 33/50\n",
      "56000/56000 - 2s - loss: 0.0067 - accuracy: 0.9979 - val_loss: 0.1207 - val_accuracy: 0.9791\n",
      "Epoch 34/50\n",
      "56000/56000 - 2s - loss: 0.0070 - accuracy: 0.9976 - val_loss: 0.1065 - val_accuracy: 0.9809\n",
      "Epoch 35/50\n",
      "56000/56000 - 2s - loss: 0.0061 - accuracy: 0.9981 - val_loss: 0.1101 - val_accuracy: 0.9801\n",
      "Epoch 36/50\n",
      "56000/56000 - 2s - loss: 0.0051 - accuracy: 0.9984 - val_loss: 0.1160 - val_accuracy: 0.9806\n",
      "Epoch 37/50\n",
      "56000/56000 - 2s - loss: 0.0069 - accuracy: 0.9978 - val_loss: 0.1139 - val_accuracy: 0.9807\n",
      "Epoch 38/50\n",
      "56000/56000 - 2s - loss: 0.0041 - accuracy: 0.9986 - val_loss: 0.1149 - val_accuracy: 0.9815\n",
      "Epoch 39/50\n",
      "56000/56000 - 2s - loss: 0.0055 - accuracy: 0.9983 - val_loss: 0.1195 - val_accuracy: 0.9808\n",
      "Epoch 40/50\n",
      "\n",
      "Epoch 00040: val_loss did not improve from 0.08028\n",
      "56000/56000 - 2s - loss: 0.0066 - accuracy: 0.9980 - val_loss: 0.1190 - val_accuracy: 0.9805\n",
      "Epoch 41/50\n",
      "56000/56000 - 2s - loss: 0.0046 - accuracy: 0.9985 - val_loss: 0.1199 - val_accuracy: 0.9807\n",
      "Epoch 42/50\n",
      "56000/56000 - 2s - loss: 0.0058 - accuracy: 0.9981 - val_loss: 0.1166 - val_accuracy: 0.9811\n",
      "Epoch 43/50\n",
      "56000/56000 - 2s - loss: 0.0042 - accuracy: 0.9986 - val_loss: 0.1357 - val_accuracy: 0.9789\n",
      "Epoch 44/50\n",
      "56000/56000 - 2s - loss: 0.0062 - accuracy: 0.9978 - val_loss: 0.1217 - val_accuracy: 0.9804\n",
      "Epoch 45/50\n",
      "56000/56000 - 2s - loss: 0.0056 - accuracy: 0.9981 - val_loss: 0.1249 - val_accuracy: 0.9804\n",
      "Epoch 46/50\n",
      "56000/56000 - 2s - loss: 0.0040 - accuracy: 0.9987 - val_loss: 0.1303 - val_accuracy: 0.9797\n",
      "Epoch 47/50\n",
      "56000/56000 - 2s - loss: 0.0065 - accuracy: 0.9982 - val_loss: 0.1186 - val_accuracy: 0.9813\n",
      "Epoch 48/50\n",
      "56000/56000 - 2s - loss: 0.0048 - accuracy: 0.9984 - val_loss: 0.1117 - val_accuracy: 0.9819\n",
      "Epoch 49/50\n",
      "56000/56000 - 2s - loss: 0.0056 - accuracy: 0.9981 - val_loss: 0.1251 - val_accuracy: 0.9818\n",
      "Epoch 50/50\n",
      "\n",
      "Epoch 00050: val_loss did not improve from 0.08028\n",
      "56000/56000 - 2s - loss: 0.0042 - accuracy: 0.9986 - val_loss: 0.1275 - val_accuracy: 0.9804\n"
     ]
    }
   ],
   "source": [
    "checkpointer = ModelCheckpoint(filepath='chapter10_exp0.h5', verbose=1,period=10, save_best_only=True)\n",
    "logdir = os.path.join(\"logs\", datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\"))\n",
    "tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir, histogram_freq=1)\n",
    "\n",
    "history_1hidden_layer = model.fit(\n",
    "    X_train_scaled,\n",
    "    y_train,\n",
    "    epochs=50,\n",
    "    verbose=2,\n",
    "    batch_size=50,\n",
    "    validation_data=(X_test_scaled, y_test),\n",
    "    callbacks=[checkpointer, tensorboard_callback]\n",
    ")\n",
    "# Save the model\n",
    "model.save('chapter10_exp0.h5')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotAccuracyAndLoss(history_1hidden_layer, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Takeaway: we can reach 98% accuracy on the val set by using only 1 hidden layer but it can barely reach it, let's try to improve it in the next experiment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "JCGe0ZMLZR-I"
   },
   "source": [
    "## experiment 1: improving accuracy by using 2 hidden layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 354
    },
    "colab_type": "code",
    "id": "I0at7u9JZU5V",
    "outputId": "b1eff543-982a-477b-e993-b77a6fa2747f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_2 (Dense)              (None, 300)               235500    \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 300)               0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 100)               30100     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 10)                1010      \n",
      "=================================================================\n",
      "Total params: 266,610\n",
      "Trainable params: 266,610\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model = Sequential([\n",
    "    Dense(300, activation='relu', input_shape=(n,)\n",
    "         ),\n",
    "    Dropout(0.1),\n",
    "    Dense(100, activation='relu', input_shape=(n,)\n",
    "         ),\n",
    "    Dropout(0.1),\n",
    "    Dense(10, activation='softmax')\n",
    "])\n",
    "#sgd = optimizers.SGD()\n",
    "model.compile(optimizer='adam',\n",
    "              loss='sparse_categorical_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "hU0iOPgDZdt9",
    "outputId": "df687c05-25ac-4f33-e253-5c280c0a982a"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0828 05:36:33.511526 140595318212416 callbacks.py:862] `period` argument is deprecated. Please use `save_freq` to specify the frequency in number of samples seen.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 56000 samples, validate on 14000 samples\n",
      "Epoch 1/50\n",
      "56000/56000 - 3s - loss: 0.2478 - accuracy: 0.9249 - val_loss: 0.1277 - val_accuracy: 0.9616\n",
      "Epoch 2/50\n",
      "56000/56000 - 3s - loss: 0.1035 - accuracy: 0.9682 - val_loss: 0.0944 - val_accuracy: 0.9715\n",
      "Epoch 3/50\n",
      "56000/56000 - 3s - loss: 0.0721 - accuracy: 0.9773 - val_loss: 0.0819 - val_accuracy: 0.9749\n",
      "Epoch 4/50\n",
      "56000/56000 - 3s - loss: 0.0583 - accuracy: 0.9813 - val_loss: 0.0839 - val_accuracy: 0.9739\n",
      "Epoch 5/50\n",
      "56000/56000 - 3s - loss: 0.0456 - accuracy: 0.9853 - val_loss: 0.0791 - val_accuracy: 0.9766\n",
      "Epoch 6/50\n",
      "56000/56000 - 3s - loss: 0.0393 - accuracy: 0.9870 - val_loss: 0.0745 - val_accuracy: 0.9780\n",
      "Epoch 7/50\n",
      "56000/56000 - 3s - loss: 0.0345 - accuracy: 0.9886 - val_loss: 0.0773 - val_accuracy: 0.9791\n",
      "Epoch 8/50\n",
      "56000/56000 - 3s - loss: 0.0274 - accuracy: 0.9910 - val_loss: 0.0785 - val_accuracy: 0.9788\n",
      "Epoch 9/50\n",
      "56000/56000 - 3s - loss: 0.0275 - accuracy: 0.9906 - val_loss: 0.0911 - val_accuracy: 0.9762\n",
      "Epoch 10/50\n",
      "\n",
      "Epoch 00010: val_loss improved from inf to 0.08567, saving model to chapter10_exp1.h5\n",
      "56000/56000 - 3s - loss: 0.0230 - accuracy: 0.9923 - val_loss: 0.0857 - val_accuracy: 0.9794\n",
      "Epoch 11/50\n",
      "56000/56000 - 3s - loss: 0.0232 - accuracy: 0.9922 - val_loss: 0.0837 - val_accuracy: 0.9786\n",
      "Epoch 12/50\n",
      "56000/56000 - 3s - loss: 0.0194 - accuracy: 0.9930 - val_loss: 0.0930 - val_accuracy: 0.9799\n",
      "Epoch 13/50\n",
      "56000/56000 - 3s - loss: 0.0207 - accuracy: 0.9933 - val_loss: 0.0832 - val_accuracy: 0.9804\n",
      "Epoch 14/50\n",
      "56000/56000 - 3s - loss: 0.0191 - accuracy: 0.9935 - val_loss: 0.0977 - val_accuracy: 0.9778\n",
      "Epoch 15/50\n",
      "56000/56000 - 3s - loss: 0.0177 - accuracy: 0.9942 - val_loss: 0.0904 - val_accuracy: 0.9803\n",
      "Epoch 16/50\n",
      "56000/56000 - 3s - loss: 0.0160 - accuracy: 0.9946 - val_loss: 0.1095 - val_accuracy: 0.9770\n",
      "Epoch 17/50\n",
      "56000/56000 - 3s - loss: 0.0153 - accuracy: 0.9950 - val_loss: 0.0989 - val_accuracy: 0.9795\n",
      "Epoch 18/50\n",
      "56000/56000 - 3s - loss: 0.0179 - accuracy: 0.9942 - val_loss: 0.0931 - val_accuracy: 0.9811\n",
      "Epoch 19/50\n",
      "56000/56000 - 3s - loss: 0.0126 - accuracy: 0.9957 - val_loss: 0.0961 - val_accuracy: 0.9806\n",
      "Epoch 20/50\n",
      "\n",
      "Epoch 00020: val_loss did not improve from 0.08567\n",
      "56000/56000 - 3s - loss: 0.0131 - accuracy: 0.9958 - val_loss: 0.0989 - val_accuracy: 0.9803\n",
      "Epoch 21/50\n",
      "56000/56000 - 3s - loss: 0.0148 - accuracy: 0.9953 - val_loss: 0.0952 - val_accuracy: 0.9800\n",
      "Epoch 22/50\n",
      "56000/56000 - 3s - loss: 0.0122 - accuracy: 0.9959 - val_loss: 0.1054 - val_accuracy: 0.9806\n",
      "Epoch 23/50\n",
      "56000/56000 - 3s - loss: 0.0135 - accuracy: 0.9957 - val_loss: 0.1181 - val_accuracy: 0.9789\n",
      "Epoch 24/50\n",
      "56000/56000 - 3s - loss: 0.0116 - accuracy: 0.9959 - val_loss: 0.1109 - val_accuracy: 0.9796\n",
      "Epoch 25/50\n",
      "56000/56000 - 3s - loss: 0.0137 - accuracy: 0.9960 - val_loss: 0.1081 - val_accuracy: 0.9794\n",
      "Epoch 26/50\n",
      "56000/56000 - 3s - loss: 0.0122 - accuracy: 0.9961 - val_loss: 0.0988 - val_accuracy: 0.9822\n",
      "Epoch 27/50\n",
      "56000/56000 - 3s - loss: 0.0133 - accuracy: 0.9959 - val_loss: 0.1052 - val_accuracy: 0.9822\n",
      "Epoch 28/50\n",
      "56000/56000 - 3s - loss: 0.0092 - accuracy: 0.9971 - val_loss: 0.1033 - val_accuracy: 0.9812\n",
      "Epoch 29/50\n",
      "56000/56000 - 3s - loss: 0.0104 - accuracy: 0.9964 - val_loss: 0.1159 - val_accuracy: 0.9808\n",
      "Epoch 30/50\n",
      "\n",
      "Epoch 00030: val_loss did not improve from 0.08567\n",
      "56000/56000 - 3s - loss: 0.0116 - accuracy: 0.9963 - val_loss: 0.1076 - val_accuracy: 0.9812\n",
      "Epoch 31/50\n",
      "56000/56000 - 3s - loss: 0.0117 - accuracy: 0.9963 - val_loss: 0.1372 - val_accuracy: 0.9786\n",
      "Epoch 32/50\n",
      "56000/56000 - 3s - loss: 0.0100 - accuracy: 0.9970 - val_loss: 0.1115 - val_accuracy: 0.9829\n",
      "Epoch 33/50\n",
      "56000/56000 - 3s - loss: 0.0096 - accuracy: 0.9969 - val_loss: 0.1152 - val_accuracy: 0.9811\n",
      "Epoch 34/50\n",
      "56000/56000 - 3s - loss: 0.0094 - accuracy: 0.9974 - val_loss: 0.1088 - val_accuracy: 0.9818\n",
      "Epoch 35/50\n",
      "56000/56000 - 3s - loss: 0.0107 - accuracy: 0.9968 - val_loss: 0.0969 - val_accuracy: 0.9835\n",
      "Epoch 36/50\n",
      "56000/56000 - 3s - loss: 0.0093 - accuracy: 0.9973 - val_loss: 0.1177 - val_accuracy: 0.9792\n",
      "Epoch 37/50\n",
      "56000/56000 - 3s - loss: 0.0104 - accuracy: 0.9966 - val_loss: 0.1168 - val_accuracy: 0.9810\n",
      "Epoch 38/50\n",
      "56000/56000 - 3s - loss: 0.0113 - accuracy: 0.9965 - val_loss: 0.1174 - val_accuracy: 0.9809\n",
      "Epoch 39/50\n",
      "56000/56000 - 3s - loss: 0.0093 - accuracy: 0.9970 - val_loss: 0.1121 - val_accuracy: 0.9829\n",
      "Epoch 40/50\n",
      "\n",
      "Epoch 00040: val_loss did not improve from 0.08567\n",
      "56000/56000 - 3s - loss: 0.0096 - accuracy: 0.9974 - val_loss: 0.1229 - val_accuracy: 0.9804\n",
      "Epoch 41/50\n",
      "56000/56000 - 3s - loss: 0.0103 - accuracy: 0.9970 - val_loss: 0.1197 - val_accuracy: 0.9801\n",
      "Epoch 42/50\n",
      "56000/56000 - 3s - loss: 0.0076 - accuracy: 0.9974 - val_loss: 0.1277 - val_accuracy: 0.9803\n",
      "Epoch 43/50\n",
      "56000/56000 - 3s - loss: 0.0100 - accuracy: 0.9969 - val_loss: 0.1202 - val_accuracy: 0.9814\n",
      "Epoch 44/50\n",
      "56000/56000 - 3s - loss: 0.0092 - accuracy: 0.9973 - val_loss: 0.1133 - val_accuracy: 0.9814\n",
      "Epoch 45/50\n",
      "56000/56000 - 3s - loss: 0.0068 - accuracy: 0.9977 - val_loss: 0.1174 - val_accuracy: 0.9824\n",
      "Epoch 46/50\n",
      "56000/56000 - 3s - loss: 0.0098 - accuracy: 0.9972 - val_loss: 0.1183 - val_accuracy: 0.9825\n",
      "Epoch 47/50\n",
      "56000/56000 - 3s - loss: 0.0083 - accuracy: 0.9976 - val_loss: 0.1323 - val_accuracy: 0.9799\n",
      "Epoch 48/50\n",
      "56000/56000 - 3s - loss: 0.0091 - accuracy: 0.9974 - val_loss: 0.1196 - val_accuracy: 0.9821\n",
      "Epoch 49/50\n",
      "56000/56000 - 3s - loss: 0.0091 - accuracy: 0.9975 - val_loss: 0.1279 - val_accuracy: 0.9814\n",
      "Epoch 50/50\n",
      "\n",
      "Epoch 00050: val_loss did not improve from 0.08567\n",
      "56000/56000 - 3s - loss: 0.0113 - accuracy: 0.9971 - val_loss: 0.1286 - val_accuracy: 0.9815\n"
     ]
    }
   ],
   "source": [
    "checkpointer = ModelCheckpoint(filepath='chapter10_exp1.h5', verbose=1,period=10, save_best_only=True)\n",
    "logdir = os.path.join(\"logs\", datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\"))\n",
    "tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir, histogram_freq=1)\n",
    "\n",
    "history = model.fit(\n",
    "    X_train_scaled,\n",
    "    y_train,\n",
    "    epochs=50,\n",
    "    verbose=2,\n",
    "    batch_size=50,\n",
    "    validation_data=(X_test_scaled, y_test),\n",
    "    callbacks=[checkpointer, tensorboard_callback]\n",
    ")\n",
    "# Save the model\n",
    "model.save('chapter10_exp1.h5')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotAccuracyAndLoss(history, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Takeaway: accuracy in validation set improved slightly by adding another hidden layer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2-8yc3VszmDT"
   },
   "source": [
    "# experiment 2: same thing, but using 10 one hot encoded classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ec2-user/anaconda3/envs/tensorflow_p36/lib/python3.6/site-packages/sklearn/preprocessing/_encoders.py:415: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values.\n",
      "If you want the future behaviour and silence this warning, you can specify \"categories='auto'\".\n",
      "In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly.\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "enc = OneHotEncoder()\n",
    "enc.fit(y_train)\n",
    "y_train_1hot_encoded = enc.transform(y_train)\n",
    "y_test_1hot_encoded = enc.transform(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0828 05:38:54.167406 140595318212416 callbacks.py:862] `period` argument is deprecated. Please use `save_freq` to specify the frequency in number of samples seen.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 56000 samples, validate on 14000 samples\n",
      "Epoch 1/50\n",
      "56000/56000 - 3s - loss: 0.2480 - accuracy: 0.9261 - val_loss: 0.1249 - val_accuracy: 0.9629\n",
      "Epoch 2/50\n",
      "56000/56000 - 3s - loss: 0.1081 - accuracy: 0.9662 - val_loss: 0.0993 - val_accuracy: 0.9698\n",
      "Epoch 3/50\n",
      "56000/56000 - 3s - loss: 0.0739 - accuracy: 0.9768 - val_loss: 0.1049 - val_accuracy: 0.9681\n",
      "Epoch 4/50\n",
      "56000/56000 - 3s - loss: 0.0580 - accuracy: 0.9814 - val_loss: 0.0861 - val_accuracy: 0.9754\n",
      "Epoch 5/50\n",
      "56000/56000 - 3s - loss: 0.0467 - accuracy: 0.9846 - val_loss: 0.0793 - val_accuracy: 0.9781\n",
      "Epoch 6/50\n",
      "56000/56000 - 3s - loss: 0.0402 - accuracy: 0.9871 - val_loss: 0.0770 - val_accuracy: 0.9794\n",
      "Epoch 7/50\n",
      "56000/56000 - 3s - loss: 0.0364 - accuracy: 0.9879 - val_loss: 0.0821 - val_accuracy: 0.9769\n",
      "Epoch 8/50\n",
      "56000/56000 - 3s - loss: 0.0311 - accuracy: 0.9903 - val_loss: 0.0839 - val_accuracy: 0.9782\n",
      "Epoch 9/50\n",
      "56000/56000 - 3s - loss: 0.0230 - accuracy: 0.9927 - val_loss: 0.0847 - val_accuracy: 0.9775\n",
      "Epoch 10/50\n",
      "\n",
      "Epoch 00010: val_loss improved from inf to 0.08567, saving model to chapter10_exp1_1hot.h5\n",
      "56000/56000 - 3s - loss: 0.0238 - accuracy: 0.9918 - val_loss: 0.0857 - val_accuracy: 0.9786\n",
      "Epoch 11/50\n",
      "56000/56000 - 3s - loss: 0.0242 - accuracy: 0.9916 - val_loss: 0.0995 - val_accuracy: 0.9759\n",
      "Epoch 12/50\n",
      "56000/56000 - 3s - loss: 0.0202 - accuracy: 0.9932 - val_loss: 0.0839 - val_accuracy: 0.9795\n",
      "Epoch 13/50\n",
      "56000/56000 - 3s - loss: 0.0195 - accuracy: 0.9930 - val_loss: 0.0896 - val_accuracy: 0.9789\n",
      "Epoch 14/50\n",
      "56000/56000 - 3s - loss: 0.0178 - accuracy: 0.9941 - val_loss: 0.0893 - val_accuracy: 0.9796\n",
      "Epoch 15/50\n",
      "56000/56000 - 3s - loss: 0.0175 - accuracy: 0.9944 - val_loss: 0.0914 - val_accuracy: 0.9798\n",
      "Epoch 16/50\n",
      "56000/56000 - 3s - loss: 0.0171 - accuracy: 0.9944 - val_loss: 0.0929 - val_accuracy: 0.9802\n",
      "Epoch 17/50\n",
      "56000/56000 - 3s - loss: 0.0159 - accuracy: 0.9947 - val_loss: 0.0907 - val_accuracy: 0.9805\n",
      "Epoch 18/50\n",
      "56000/56000 - 3s - loss: 0.0123 - accuracy: 0.9956 - val_loss: 0.0913 - val_accuracy: 0.9809\n",
      "Epoch 19/50\n",
      "56000/56000 - 3s - loss: 0.0178 - accuracy: 0.9943 - val_loss: 0.0928 - val_accuracy: 0.9804\n",
      "Epoch 20/50\n",
      "\n",
      "Epoch 00020: val_loss did not improve from 0.08567\n",
      "56000/56000 - 3s - loss: 0.0157 - accuracy: 0.9951 - val_loss: 0.0881 - val_accuracy: 0.9825\n",
      "Epoch 21/50\n",
      "56000/56000 - 3s - loss: 0.0133 - accuracy: 0.9954 - val_loss: 0.0919 - val_accuracy: 0.9819\n",
      "Epoch 22/50\n",
      "56000/56000 - 3s - loss: 0.0121 - accuracy: 0.9961 - val_loss: 0.0986 - val_accuracy: 0.9807\n",
      "Epoch 23/50\n",
      "56000/56000 - 3s - loss: 0.0148 - accuracy: 0.9953 - val_loss: 0.0960 - val_accuracy: 0.9816\n",
      "Epoch 24/50\n",
      "56000/56000 - 3s - loss: 0.0107 - accuracy: 0.9967 - val_loss: 0.0962 - val_accuracy: 0.9806\n",
      "Epoch 25/50\n",
      "56000/56000 - 3s - loss: 0.0136 - accuracy: 0.9956 - val_loss: 0.0953 - val_accuracy: 0.9824\n",
      "Epoch 26/50\n",
      "56000/56000 - 3s - loss: 0.0122 - accuracy: 0.9961 - val_loss: 0.1014 - val_accuracy: 0.9810\n",
      "Epoch 27/50\n",
      "56000/56000 - 3s - loss: 0.0108 - accuracy: 0.9965 - val_loss: 0.1023 - val_accuracy: 0.9822\n",
      "Epoch 28/50\n",
      "56000/56000 - 3s - loss: 0.0136 - accuracy: 0.9958 - val_loss: 0.1075 - val_accuracy: 0.9794\n",
      "Epoch 29/50\n",
      "56000/56000 - 3s - loss: 0.0121 - accuracy: 0.9960 - val_loss: 0.0939 - val_accuracy: 0.9827\n",
      "Epoch 30/50\n",
      "\n",
      "Epoch 00030: val_loss did not improve from 0.08567\n",
      "56000/56000 - 3s - loss: 0.0091 - accuracy: 0.9971 - val_loss: 0.1068 - val_accuracy: 0.9820\n",
      "Epoch 31/50\n",
      "56000/56000 - 3s - loss: 0.0115 - accuracy: 0.9964 - val_loss: 0.1039 - val_accuracy: 0.9819\n",
      "Epoch 32/50\n",
      "56000/56000 - 3s - loss: 0.0099 - accuracy: 0.9969 - val_loss: 0.1073 - val_accuracy: 0.9811\n",
      "Epoch 33/50\n",
      "56000/56000 - 3s - loss: 0.0103 - accuracy: 0.9968 - val_loss: 0.1192 - val_accuracy: 0.9786\n",
      "Epoch 34/50\n",
      "56000/56000 - 3s - loss: 0.0116 - accuracy: 0.9961 - val_loss: 0.1069 - val_accuracy: 0.9816\n",
      "Epoch 35/50\n",
      "56000/56000 - 3s - loss: 0.0098 - accuracy: 0.9970 - val_loss: 0.1032 - val_accuracy: 0.9826\n",
      "Epoch 36/50\n",
      "56000/56000 - 3s - loss: 0.0100 - accuracy: 0.9969 - val_loss: 0.1100 - val_accuracy: 0.9826\n",
      "Epoch 37/50\n",
      "56000/56000 - 3s - loss: 0.0090 - accuracy: 0.9971 - val_loss: 0.1116 - val_accuracy: 0.9811\n",
      "Epoch 38/50\n",
      "56000/56000 - 3s - loss: 0.0091 - accuracy: 0.9971 - val_loss: 0.1008 - val_accuracy: 0.9834\n",
      "Epoch 39/50\n",
      "56000/56000 - 3s - loss: 0.0080 - accuracy: 0.9974 - val_loss: 0.1107 - val_accuracy: 0.9817\n",
      "Epoch 40/50\n",
      "\n",
      "Epoch 00040: val_loss did not improve from 0.08567\n",
      "56000/56000 - 3s - loss: 0.0100 - accuracy: 0.9970 - val_loss: 0.1171 - val_accuracy: 0.9826\n",
      "Epoch 41/50\n",
      "56000/56000 - 3s - loss: 0.0108 - accuracy: 0.9971 - val_loss: 0.1050 - val_accuracy: 0.9813\n",
      "Epoch 42/50\n",
      "56000/56000 - 3s - loss: 0.0061 - accuracy: 0.9980 - val_loss: 0.1260 - val_accuracy: 0.9815\n",
      "Epoch 43/50\n",
      "56000/56000 - 3s - loss: 0.0102 - accuracy: 0.9970 - val_loss: 0.1252 - val_accuracy: 0.9805\n",
      "Epoch 44/50\n",
      "56000/56000 - 3s - loss: 0.0089 - accuracy: 0.9974 - val_loss: 0.1250 - val_accuracy: 0.9819\n",
      "Epoch 45/50\n",
      "56000/56000 - 3s - loss: 0.0086 - accuracy: 0.9975 - val_loss: 0.1314 - val_accuracy: 0.9821\n",
      "Epoch 46/50\n",
      "56000/56000 - 3s - loss: 0.0093 - accuracy: 0.9976 - val_loss: 0.1134 - val_accuracy: 0.9813\n",
      "Epoch 47/50\n",
      "56000/56000 - 3s - loss: 0.0085 - accuracy: 0.9975 - val_loss: 0.1107 - val_accuracy: 0.9836\n",
      "Epoch 48/50\n",
      "56000/56000 - 3s - loss: 0.0099 - accuracy: 0.9971 - val_loss: 0.1184 - val_accuracy: 0.9824\n",
      "Epoch 49/50\n",
      "56000/56000 - 3s - loss: 0.0091 - accuracy: 0.9973 - val_loss: 0.1261 - val_accuracy: 0.9816\n",
      "Epoch 50/50\n",
      "\n",
      "Epoch 00050: val_loss did not improve from 0.08567\n",
      "56000/56000 - 3s - loss: 0.0102 - accuracy: 0.9970 - val_loss: 0.1282 - val_accuracy: 0.9824\n"
     ]
    }
   ],
   "source": [
    "\n",
    "checkpointer = ModelCheckpoint(filepath='chapter10_exp1_1hot.h5', verbose=1,period=10, save_best_only=True)\n",
    "logdir = os.path.join(\"logs\", datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\"))\n",
    "tensorboard_callback = tf.keras.callbacks.TensorBoard(logdir, histogram_freq=1)\n",
    "model2 = Sequential([\n",
    "    Dense(300, activation='relu', input_shape=(n,)\n",
    "         ),\n",
    "    Dropout(0.1),\n",
    "    Dense(100, activation='relu', input_shape=(n,)\n",
    "         ),\n",
    "    Dropout(0.1),\n",
    "    Dense(10, activation='softmax')\n",
    "])\n",
    "#sgd = optimizers.SGD()\n",
    "model2.compile(optimizer='adam',\n",
    "              loss='categorical_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "history2 = model2.fit(\n",
    "    X_train_scaled,\n",
    "    y_train_1hot_encoded,\n",
    "    epochs=50,\n",
    "    verbose=2,\n",
    "    batch_size=50,\n",
    "    validation_data=(X_test_scaled, y_test_1hot_encoded),\n",
    "    callbacks=[checkpointer, tensorboard_callback]\n",
    ")\n",
    "# Save the model\n",
    "model.save('chapter10_exp1_1hot.h5')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plotAccuracyAndLoss(history2, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## the difference is not high, AFAIK they work the same way under the hood"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions1 = model.predict(X_test_scaled)\n",
    "predictions2 = model2.predict(X_test_scaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.9889695e-31, 3.9195545e-23, 1.4431810e-34, 3.4412568e-36,\n",
       "       1.0000000e+00, 6.2319482e-30, 6.9843374e-34, 1.3839180e-19,\n",
       "       7.1200790e-27, 1.7089571e-18], dtype=float32)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictions1[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.0000000e+00, 1.5610629e-28, 8.6848393e-38, 0.0000000e+00,\n",
       "       1.0000000e+00, 4.5069746e-31, 4.3797284e-36, 3.2394796e-27,\n",
       "       3.3994779e-29, 2.4867665e-24], dtype=float32)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictions2[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## experiment 3: one hot encode output BUT drop 1st column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "enc = OneHotEncoder(drop='first', categories='auto')\n",
    "enc.fit(y_train)\n",
    "y_train_1hot_encoded_drop1st = enc.transform(y_train)\n",
    "y_test_1hot_encoded_drop1st = enc.transform(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0828 05:41:26.542402 140595318212416 callbacks.py:862] `period` argument is deprecated. Please use `save_freq` to specify the frequency in number of samples seen.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 56000 samples, validate on 14000 samples\n",
      "Epoch 1/50\n",
      "56000/56000 - 3s - loss: 0.2198 - accuracy: 0.8348 - val_loss: 0.1070 - val_accuracy: 0.8719\n",
      "Epoch 2/50\n",
      "56000/56000 - 3s - loss: 0.0928 - accuracy: 0.8719 - val_loss: 0.0860 - val_accuracy: 0.8772\n",
      "Epoch 3/50\n",
      "56000/56000 - 3s - loss: 0.0651 - accuracy: 0.8802 - val_loss: 0.0772 - val_accuracy: 0.8806\n",
      "Epoch 4/50\n",
      "56000/56000 - 3s - loss: 0.0497 - accuracy: 0.8844 - val_loss: 0.0812 - val_accuracy: 0.8806\n",
      "Epoch 5/50\n",
      "56000/56000 - 3s - loss: 0.0413 - accuracy: 0.8876 - val_loss: 0.0748 - val_accuracy: 0.8839\n",
      "Epoch 6/50\n",
      "56000/56000 - 3s - loss: 0.0357 - accuracy: 0.8889 - val_loss: 0.0709 - val_accuracy: 0.8838\n",
      "Epoch 7/50\n",
      "56000/56000 - 3s - loss: 0.0324 - accuracy: 0.8902 - val_loss: 0.0725 - val_accuracy: 0.8853\n",
      "Epoch 8/50\n",
      "56000/56000 - 3s - loss: 0.0261 - accuracy: 0.8921 - val_loss: 0.0756 - val_accuracy: 0.8843\n",
      "Epoch 9/50\n",
      "56000/56000 - 3s - loss: 0.0225 - accuracy: 0.8932 - val_loss: 0.0762 - val_accuracy: 0.8854\n",
      "Epoch 10/50\n",
      "\n",
      "Epoch 00010: val_loss improved from inf to 0.07791, saving model to chapter10_exp1_drop1st.h5\n",
      "56000/56000 - 3s - loss: 0.0235 - accuracy: 0.8929 - val_loss: 0.0779 - val_accuracy: 0.8850\n",
      "Epoch 11/50\n",
      "56000/56000 - 3s - loss: 0.0201 - accuracy: 0.8944 - val_loss: 0.0781 - val_accuracy: 0.8837\n",
      "Epoch 12/50\n",
      "56000/56000 - 3s - loss: 0.0194 - accuracy: 0.8945 - val_loss: 0.0770 - val_accuracy: 0.8861\n",
      "Epoch 13/50\n",
      "56000/56000 - 3s - loss: 0.0174 - accuracy: 0.8953 - val_loss: 0.0818 - val_accuracy: 0.8851\n",
      "Epoch 14/50\n",
      "56000/56000 - 3s - loss: 0.0163 - accuracy: 0.8954 - val_loss: 0.0907 - val_accuracy: 0.8854\n",
      "Epoch 15/50\n",
      "56000/56000 - 3s - loss: 0.0138 - accuracy: 0.8963 - val_loss: 0.0933 - val_accuracy: 0.8852\n",
      "Epoch 16/50\n",
      "56000/56000 - 3s - loss: 0.0160 - accuracy: 0.8955 - val_loss: 0.0842 - val_accuracy: 0.8862\n",
      "Epoch 17/50\n",
      "56000/56000 - 3s - loss: 0.0137 - accuracy: 0.8960 - val_loss: 0.1040 - val_accuracy: 0.8838\n",
      "Epoch 18/50\n",
      "56000/56000 - 3s - loss: 0.0128 - accuracy: 0.8966 - val_loss: 0.0915 - val_accuracy: 0.8859\n",
      "Epoch 19/50\n",
      "56000/56000 - 3s - loss: 0.0148 - accuracy: 0.8961 - val_loss: 0.0907 - val_accuracy: 0.8859\n",
      "Epoch 20/50\n",
      "\n",
      "Epoch 00020: val_loss did not improve from 0.07791\n",
      "56000/56000 - 3s - loss: 0.0112 - accuracy: 0.8970 - val_loss: 0.1047 - val_accuracy: 0.8849\n",
      "Epoch 21/50\n",
      "56000/56000 - 3s - loss: 0.0119 - accuracy: 0.8969 - val_loss: 0.0982 - val_accuracy: 0.8859\n",
      "Epoch 22/50\n",
      "56000/56000 - 3s - loss: 0.0122 - accuracy: 0.8969 - val_loss: 0.0946 - val_accuracy: 0.8859\n",
      "Epoch 23/50\n",
      "56000/56000 - 3s - loss: 0.0119 - accuracy: 0.8966 - val_loss: 0.1044 - val_accuracy: 0.8859\n",
      "Epoch 24/50\n",
      "56000/56000 - 3s - loss: 0.0120 - accuracy: 0.8971 - val_loss: 0.0951 - val_accuracy: 0.8866\n",
      "Epoch 25/50\n",
      "56000/56000 - 3s - loss: 0.0109 - accuracy: 0.8971 - val_loss: 0.0916 - val_accuracy: 0.8871\n",
      "Epoch 26/50\n",
      "56000/56000 - 3s - loss: 0.0093 - accuracy: 0.8979 - val_loss: 0.1054 - val_accuracy: 0.8866\n",
      "Epoch 27/50\n",
      "56000/56000 - 3s - loss: 0.0103 - accuracy: 0.8977 - val_loss: 0.1074 - val_accuracy: 0.8864\n",
      "Epoch 28/50\n",
      "56000/56000 - 3s - loss: 0.0102 - accuracy: 0.8978 - val_loss: 0.1048 - val_accuracy: 0.8861\n",
      "Epoch 29/50\n",
      "56000/56000 - 3s - loss: 0.0111 - accuracy: 0.8975 - val_loss: 0.1184 - val_accuracy: 0.8853\n",
      "Epoch 30/50\n",
      "\n",
      "Epoch 00030: val_loss did not improve from 0.07791\n",
      "56000/56000 - 3s - loss: 0.0109 - accuracy: 0.8975 - val_loss: 0.1130 - val_accuracy: 0.8850\n",
      "Epoch 31/50\n",
      "56000/56000 - 3s - loss: 0.0072 - accuracy: 0.8985 - val_loss: 0.1287 - val_accuracy: 0.8836\n",
      "Epoch 32/50\n",
      "56000/56000 - 3s - loss: 0.0110 - accuracy: 0.8978 - val_loss: 0.1058 - val_accuracy: 0.8874\n",
      "Epoch 33/50\n",
      "56000/56000 - 3s - loss: 0.0096 - accuracy: 0.8976 - val_loss: 0.1126 - val_accuracy: 0.8861\n",
      "Epoch 34/50\n",
      "56000/56000 - 3s - loss: 0.0060 - accuracy: 0.8988 - val_loss: 0.1291 - val_accuracy: 0.8852\n",
      "Epoch 35/50\n",
      "56000/56000 - 3s - loss: 0.0102 - accuracy: 0.8983 - val_loss: 0.1303 - val_accuracy: 0.8859\n",
      "Epoch 36/50\n",
      "56000/56000 - 3s - loss: 0.0104 - accuracy: 0.8978 - val_loss: 0.1177 - val_accuracy: 0.8856\n",
      "Epoch 37/50\n",
      "56000/56000 - 3s - loss: 0.0070 - accuracy: 0.8986 - val_loss: 0.1124 - val_accuracy: 0.8872\n",
      "Epoch 38/50\n",
      "56000/56000 - 3s - loss: 0.0098 - accuracy: 0.8980 - val_loss: 0.1130 - val_accuracy: 0.8858\n",
      "Epoch 39/50\n",
      "56000/56000 - 3s - loss: 0.0086 - accuracy: 0.8985 - val_loss: 0.1014 - val_accuracy: 0.8879\n",
      "Epoch 40/50\n",
      "\n",
      "Epoch 00040: val_loss did not improve from 0.07791\n",
      "56000/56000 - 3s - loss: 0.0070 - accuracy: 0.8985 - val_loss: 0.1128 - val_accuracy: 0.8871\n",
      "Epoch 41/50\n",
      "56000/56000 - 3s - loss: 0.0102 - accuracy: 0.8978 - val_loss: 0.1096 - val_accuracy: 0.8865\n",
      "Epoch 42/50\n",
      "56000/56000 - 3s - loss: 0.0059 - accuracy: 0.8990 - val_loss: 0.1205 - val_accuracy: 0.8870\n",
      "Epoch 43/50\n",
      "56000/56000 - 3s - loss: 0.0069 - accuracy: 0.8988 - val_loss: 0.1247 - val_accuracy: 0.8852\n",
      "Epoch 44/50\n",
      "56000/56000 - 3s - loss: 0.0078 - accuracy: 0.8987 - val_loss: 0.1318 - val_accuracy: 0.8853\n",
      "Epoch 45/50\n",
      "56000/56000 - 3s - loss: 0.0082 - accuracy: 0.8983 - val_loss: 0.1294 - val_accuracy: 0.8849\n",
      "Epoch 46/50\n",
      "56000/56000 - 3s - loss: 0.0081 - accuracy: 0.8984 - val_loss: 0.1123 - val_accuracy: 0.8871\n",
      "Epoch 47/50\n",
      "56000/56000 - 3s - loss: 0.0071 - accuracy: 0.8983 - val_loss: 0.1211 - val_accuracy: 0.8876\n",
      "Epoch 48/50\n",
      "56000/56000 - 3s - loss: 0.0085 - accuracy: 0.8985 - val_loss: 0.1178 - val_accuracy: 0.8881\n",
      "Epoch 49/50\n",
      "56000/56000 - 3s - loss: 0.0064 - accuracy: 0.8989 - val_loss: 0.1275 - val_accuracy: 0.8858\n",
      "Epoch 50/50\n",
      "\n",
      "Epoch 00050: val_loss did not improve from 0.07791\n",
      "56000/56000 - 3s - loss: 0.0058 - accuracy: 0.8992 - val_loss: 0.1208 - val_accuracy: 0.8867\n"
     ]
    }
   ],
   "source": [
    "checkpointer = ModelCheckpoint(filepath='chapter10_exp1_drop1st.h5', verbose=1,period=10, save_best_only=True)\n",
    "model3 = Sequential([\n",
    "    Dense(300, activation='relu', input_shape=(n,)\n",
    "         ),\n",
    "    Dropout(0.1),\n",
    "    Dense(100, activation='relu', input_shape=(n,)\n",
    "         ),\n",
    "    Dropout(0.1),\n",
    "    Dense(9, activation='softmax')#CHANGE THE NO. OF UNITS IM OUTPUT LAYER TO SUPPORT NEW TARGET!\n",
    "])\n",
    "model3.compile(optimizer='adam',\n",
    "              loss='categorical_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "history3 = model3.fit(\n",
    "    X_train_scaled,\n",
    "    y_train_1hot_encoded_drop1st,\n",
    "    epochs=50,\n",
    "    verbose=2,\n",
    "    batch_size=50,\n",
    "    validation_data=(X_test_scaled, y_test_1hot_encoded_drop1st),\n",
    "    callbacks=[checkpointer, tensorboard_callback]\n",
    ")\n",
    "model.save('chapter10_exp1_1hot_drop1st.h5')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe0AAAHwCAYAAACL/De+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd4lFXa+PHvmZkUQhohAQwBEum9RVCKoIgCIqzKqiyiYMF17WVfef25rm1fXXVd1rJ2dC2ILqwrKogNBUSlSi9BCJCEkkB6n+T8/jiTZBKSyRNSJpPcn+vKlZmnnplknnvOOfc5j9JaI4QQQojmz+btAgghhBDCGgnaQgghhI+QoC2EEEL4CAnaQgghhI+QoC2EEEL4CAnaQgghhI9oNUFbKWVXSuUopbo25LbepJTqoZRqlDF7VY+tlPpSKTWrMcqhlPqTUuqVM91fCKvkOlC/Y8t1wPuabdB2fVjKfkqVUvluz6v9p/FEa12itQ7WWh9uyG2bK6XU10qph6tZfqVSKlkpZa/L8bTWF2ut32+Acl2klEqscuzHtda/r++xazmnVkrd11jnEI1DrgP1I9cBUErdpJT6rqGP6y3NNmi7PizBWutg4DBwmduy0/5plFKOpi9ls/YvYHY1y2cD72mtS5q4PN50PXAKuK6pTyz/l/Uj14F6k+tAS6O1bvY/QCJwUZVlTwAfAh8A2cAc4DzgJyADOAo8D/i5tncAGoh1PX/PtX6Fa/8fgbi6butaPxnYB2QCLwA/AHNqeC1WyngLsB9IB55329cO/B04CRwAbjd/wmrP09ZV1lFuy9oDRUB/1/NpwC9AFuaC+Ce3bXu4HxtYW/aaaisHcBOw23X+X4GbXMvDgHygFMhx/XRw/S3fdtv/cmCn6z36Fujtti4JuBfY7nq/PwACPPzvhAC5wNVAMTCkyvrzXX+PTOAIMNu1PMj1Gg+71q0GAoCLgMQqx0gCxp/J/6Vrn4HA15gvFseA/wE6A3lAuNt2I1zrHd7+TMp1QK4DtZWDZnIdcJXjuxrWxQCfYT57CcANbuvOBTa73pfjwDNu14ZFrtedAawHIpvsc+DtD2I9P6xFwGWYFoM2wDnASNc//dmuD9DtHj6AaUA84If54L93Btt2cP1TTnetuxcTHGr6sFop4yeuf+xY1z/TRa71t7v+iWMwH7zV1PBhdW3/FvCK2/PbgI1uzy8E+rvev8Gu1zjVwofVYzlcf5OzAeU6Rz4wyLWuuqBX/mEF+mI+xBe63s8Hgb1UXNCSMBe7Tq5z78N1MajhPZjr2seGudj+3W1dnOtcV7ne+0hcQR14FfgGOAtzcRrjKo+VoF2X/8swzAXhLsyXglBghGvdl8DNbud5wb38re0HuQ7IdeAMrgN4Dto/YD5XgcAw12sf51q3AZjpehwCjHR7//6L+V+zu/4fgpvsc+DtD2I9P6zf1rLf/cC/PXwA3f+RpwE7zmDbG4A1busU5ptztR9Wi2U81239f4D7XY9Xu/9jAlPw/GEdj/mwB7ie/wzc4WH7F6n4Nunpw1rXcnwG3OZ6XNuH9VFgkds6G6Z2Ocb1PAm4xm39c8CLHs79HfCs6/FsTIB0uJ7/qey9r7KPHSjEVROpss5K0K7L/+VsYEMN280Cvnf730gFhjX058tXfpDrgFwHzuA6QA1BG/OlvRho67bsGeAN1+N1wMNA+yr7zXO9DwO98Tlotn3aFh1xf6KU6qOU+lwpdUwplQU8hqk91eSY2+M8IPgMto12L4c2f9Wkmg5isYyWzgUc8lBegO8xTTuXKaV6AUMxzUhlZTlPKfWdUipVKZWJ+ef29H6V8VgOpdRUpdTPSqlTSqkM4GKLxy07dvnxtNalmPezs9s2lv5uSqlYTPN3Wd/nx65tJ7med8E021XVEfCvYZ0Vdfm/rKkMZeUd7MpengSc0FpvPsMytWRyHfCsVV8HajlHmtY6123ZIbdzzAX6AXuVUuuVUlNcy9/GdGd95Erme6opcyl8PWjrKs9fBXYAPbTWoZhvSaqRy3AU0zwEgFJKUfkfq6r6lPEo5iJfxuNQFNeF4x1MAtZsYLnWOs1tk8XAUqCL1joMeMNiWWosh1KqDbAEeBLoqLUOxzTzlh236t+sqhSgm9vxbJj3N9lCuaq6znXeFUqpY5j+QX9MYhqYC073avY7jmlyrW5dLqZPq6x8DkzznLu6/F/WVAa01nmYv88szN/v3eq2E3Id8LSxXAc8niNSKdXWbVnXsnNorfdqra/BdH38DViqlArUWhdprR/RWvfFdJtdjvmMNglfD9pVhWCSEnKVUn0xiRyN7TNgmFLqMtcF/C4gqpHK+BFwt1Kqs1KqPfCAhX3ewdTSbsBkklYtyymtdYFS6lzgmgYoRwAmMKYCJUqpqcAEt/XHMR+UEA/HnqaUGq+U8gP+iOkr/Nli2dxdh7kYDnH7uRpT42iHae6c5Br+4lBKRSqlBmuTUfs2sEAp1ck1Xne0qzx7gBCl1CWu53/G9Ll54ulvvgzoqpS6XSkVoJQKVUqNcFv/DuZvd6mrvKJ2ch04XWu+DgDYlFKB7j9a64PARuD/XJ+9IZja9XsASqnZSqlIVy0/E/NFo1QpdaFSaoDri0QWpom99AzLVfcX0lQnaiL3YWpR2Zhvsh829gm11scxgeA5TDZhd2ALpk+0ocv4MiY5ajsmSWKJhfLtx2Q3BgCfV1l9K/CkUiobk+jxUX3LobXOAO7BNO2eAmZgLmhl63dgvtUnKqUylFIdqpR3J+b9eRnzgZ8ETNNaF1ssGwBKqTGY5q+XtNbHyn5c5UoErnZ9aC/DXGxOYTJFB7oOcQ8m83WTa93/AUprnQ7cgbnwJVOR8e1JjX9zrXUmMBG4EnMh2weMc9t3NaaP82etdY3NraISuQ6cXr5WeR1wMxaTCOf+A+Zv1hPzGV4CPKi1/s61bgqw2/W+PIu5ZhRhriv/wQTsnZim8kVnWK46U66OddFAXJMVpAAztNZrvF0e4fuUUquBhVrrt71dFmGNXAdEY2lpNW2vUEpNUkqFK6UCMBnJxZhvtULUi6u5cgDwb2+XRXgm1wHRFCRoN4wxmMkFUoFLgMu11jU1iwlhiVLqfeAL4K4qGa6ieZLrgGh00jwuhBBC+AipaQshhBA+QoK2EEII4SOa3R1xIiMjdWxsrLeLIUSzt2nTpjSttaexwF4nn2chrLH6eW52QTs2NpaNGzd6uxhCNHtKqdqmr/Q6+TwLYY3Vz7M0jwshhBA+QoK2EEII4SMkaAshhBA+otn1aQshhPCsuLiYpKQkCgoKvF0UUUeBgYHExMTg51fbfYaqJ0FbCCF8TFJSEiEhIcTGxmLuAip8gdaakydPkpSURFxc3BkdQ5rHhRDCxxQUFNC+fXsJ2D5GKUX79u3r1UIiQVsIIXyQBGzfVN+/mwRtIYQQdXLy5EmGDBnCkCFD6NSpE507dy5/XlRUZOkYc+fOZe/evR63eemll3j//fcbosiMGTOGX375pUGO5U3Spy2EEKJO2rdvXx4AH3nkEYKDg7n//vsrbaO1RmuNzVZ93fCtt96q9Ty33XZb/QvbwliqabvuE7tXKbVfKTW/mvXdlFLfKKW2KaW+U0rFuK27XimV4Pq5viELL4QQovnYv38//fr1Y9asWfTv35+jR48yb9484uPj6d+/P4899lj5tmU1X6fTSXh4OPPnz2fw4MGcd955nDhxAoCHHnqIBQsWlG8/f/58RowYQe/evVm3bh0Aubm5XHnllfTr148ZM2YQHx9vuUadn5/P9ddfz8CBAxk2bBirV68GYPv27ZxzzjkMGTKEQYMGceDAAbKzs5k8eTKDBw9mwIABLFmypCHfOstqrWkrpezAS8BEIAnYoJRaprXe5bbZs8A7Wut/KaUuBJ4EZiulIoA/A/GABja59k1v6BcihBCt0aOf7mRXSlaDHrNfdCh/vqz/Ge27Z88e3nnnHeLj4wF46qmniIiIwOl0csEFFzBjxgz69etXaZ/MzEzGjRvHU089xb333svChQuZP/+0+iFaa9avX8+yZct47LHH+OKLL3jhhRfo1KkTS5cuZevWrQwbNsxyWZ9//nkCAgLYvn07O3fuZMqUKSQkJPDPf/6T+++/n6uvvprCwkK01nzyySfExsayYsWK8jJ7g5Wa9ghgv9b6gNa6CFgMTK+yTT/gW9fjVW7rLwG+0lqfcgXqr4BJ9S+2EEKI5qh79+7lARvggw8+YNiwYQwbNozdu3eza9eu0/Zp06YNkydPBmD48OEkJiZWe+wrrrjitG3Wrl3LNddcA8DgwYPp39/6l421a9dy7bXXAtC/f3+io6PZv38/o0aN4oknnuDpp5/myJEjBAYGMmjQIL744gvmz5/PDz/8QFhYmOXzNCQrfdqdgSNuz5OAkVW22QpcAfwDuBwIUUq1r2HfzmdcWiGEEJWcaY24sbRt27b8cUJCAv/4xz9Yv3494eHhXHvttdUOd/L39y9/bLfbcTqd1R47ICCg1m0awuzZsznvvPP4/PPPmTRpEgsXLuT8889n48aNLF++nPnz5zN58mQefPDBRitDTRoqe/x+YJxSagswDkgGSqzurJSap5TaqJTamJqa2kBFEkII4U1ZWVmEhIQQGhrK0aNHWblyZYOfY/To0Xz00UeA6YuuriZfk7Fjx5Znp+/evZujR4/So0cPDhw4QI8ePbjrrruYOnUq27ZtIzk5meDgYGbPns19993H5s2bG/y1WGGlpp0MdHF7HuNaVk5rnYKpaaOUCgau1FpnKKWSgfFV9v2u6gm01q8BrwHEx8dr68UXQgjRXA0bNox+/frRp08funXrxujRoxv8HHfccQfXXXcd/fr1K/+pqen6kksuKZ8+dOzYsSxcuJBbbrmFgQMH4ufnxzvvvIO/vz+LFi3igw8+wM/Pj+joaB555BHWrVvH/Pnzsdls+Pv788orrzT4a7FCae05RiqlHMA+YAImWG8Afqe13um2TSRwSmtdqpT6C1CitX7YlYi2CSjLDNgMDNdan6rpfPHx8VruvytE7ZRSm7TW8bVv6T3yeW4cu3fvpm/fvt4uRrPgdDpxOp0EBgaSkJDAxRdfTEJCAg5H8x3RXN3fz+rnudZXpbV2KqVuB1YCdmCh1nqnUuoxYKPWehmmNv2kUkoDq4HbXPueUko9jgn0AI95CthCCChylnIqt4hOYYHeLkqjyytyUlKqCQk8s5snCJGTk8OECRNwOp1orXn11VebdcCuL0uvTGu9HFheZdnDbo+XANUOWtNaLwQW1qOMQrQKuYVOPlh/mDfXHqRrRBAf3nKet4vU6G59bzMZ+cV8clvDN5uK1iE8PJxNmzZ5uxhNpuV+HRGint7/+RAZecVMGxxNl4igRjtPZn4xb6w5wDs/HiIzv5iRcRH8fnx3tNYtfn5ph01RUlrq7WII4TMkaItmr8hZip9dNWkA23c8m4f+uwOt4ZmVexnaNZxpg6M5JzaCHh2CCfSzN8h5dqZk8vv3NpGUns/F/Try+3HdGdq1XYMc2xfYbQpnieSeCmGVBG3RrGXmFTPx79/Tq2MI/7hmCO2DAzxun1vopNBZSkRbf4/b1ea5L/fR1t/B4nnnsiYhjWVbU3j0UzOUxKYgNrItAzuHcev47vTpFHpG5/jP5iT+9z/baRfkz5Lfj2J4t9YTrMs47IqSUgnaQlglQVs0uSOn8nhyxW7undibHh2CPW77z+/3k5pTSEZ+MZe9sJZXZg9nUEx4tdvmFTm54p/rOJZVwFtzz2FYlRprZl4xC384SHFJKSGBfoQEOugSEcT5PSMr1eK3JWXwxc5j3H1RTwZ0DmOAKzgnpuWyMyWLvcey2Hs8m+/2pvLp1hSuPbcb907sRXiQtS8KR07l8drqA7z70yFGxkXw4u+GERXi+ctIS2W32SRoC1EHErRFk3v00518vfsE25Iy+c8fRtEhpPos6aOZ+bz9QyKXD+nM3NFx/P69Tcx45Ucen96fq8/pWmlbrTXzl25n34lszgoNZNbrP/PadcMZ2zMKMIH4D+9vJjkjH7tSON0CxV0TenLPxF7lz5/9ch/tgvy4cUxcpXPERrYlNrItlw46C4CMvCL+/tU+3v3pEMu2pnD50M5k5BWTnJFPSkY+/nab2ad9W2LatSHhRDY/7D/J4VN5ANw0Jo75k/vgsLfeO+Q6bJX/FsI3XHDBBcyfP59LLrmkfNmCBQvYu3cvL7/8co37BQcHk5OTQ0pKCnfeeWe1N90YP348zz77bKWpUKtasGAB8+bNIyjI5JpMmTKFRYsWER5e/Rd6q2q6Y1lz0nqvFsIr1iSk8vXuE1w5LIaTOUXc8PYGcgurn45wwVcJaA33TOzFwJgwPr1jDCPjInhg6Xbu/fAXctz2e3tdIsu2pnD/xb357+2j6dY+iBve3sDy7Uf517pEZrz8I1rDf24dRcJfJrP7sUmsf3ACvx0ewz++SeDV738F4OcDJ1m9L5Vbx3evdRhSeJA/j04fwPK7xtI/OpT3fjrEhkQzojG+Wzt6dwohJSOfResP8dhnu/hs61F6dQzhz5f14+t7x/HQ1H6tOmBDWZ+2JKL5mpkzZ7J48eJKyxYvXszMmTMt7R8dHV2vu2QtWLCAvLy88ufLly+vd8D2FVLTFk3GWVLK45/tomtEEP93xQAuHdSJm/61kdsWbeaN6+IrBbCE49n8e9MR5oyKK8/cjmjrz9tzR/D8Nwm88G0Cmw+n8/zMoRQ6S/nL57u5qG9Hbh3XHZtN8eEt53HD2xv4w/tmqsEJfTrwt6sGlzdht/G308bfzlNXDiK/uIQnV+yhjb+dT7em0CEkgOvOi7X8uvp0CuX9m86tMdu7tFSTlltIRJB/qw/SVUlN2zfNmDGDhx56iKKiIvz9/UlMTCQlJYWxY8eSk5PD9OnTSU9Pp7i4mCeeeILp0yvfYyoxMZGpU6eyY8cO8vPzmTt3Llu3bqVPnz7k5+eXb3frrbeyYcMG8vPzmTFjBo8++ijPP/88KSkpXHDBBURGRrJq1SpiY2PZuHEjkZGRPPfccyxcaEYZ33TTTdx9990kJiYyefJkxowZw7p16+jcuTOffPIJbdq0sfR6qztmbm4uV111FUlJSZSUlPCnP/2Jq6++mvnz57Ns2TIcDgcXX3wxzz77bAO964YEbWFJdkExD3+yk27tg5g2OJqzoyr6oktLNb+m5lBUUkr/6JrvfPPBhiPsO57DK9cOJ8Bh58I+HXniNwN58OPt3PfvrTwwqQ/R4eZD9MzKvQT5O7j9wh6VjmG3Ke6Z2IvRPSK5e/EWrnx5HW0DHMS0a8PfrhqMzWaCZlgbP969cQSPLttFz47B3DA6rnxd1eP9/eohFBSX8PAnZpK/x6f3P6Ps8Jqy2202VWMXQGsniWgNYMV8OLa9YY/ZaSBMfqrG1REREYwYMYIVK1Ywffp0Fi9ezFVXXYVSisDAQD7++GNCQ0NJS0vj3HPPZdq0aTV+Pl5++WWCgoLYvXs327Ztq3Rrzb/85S9ERERQUlLChAkT2LZtG3feeSfPPfccq1atIjIystKxNm3axFtvvcXPP/+M1pqRI0cybtw42rVrR0JCAh988AGvv/46V111FUuXLi2/w5cnNR3zwIEDREdH8/nnnwPmVp0nT57k448/Zs+ePSilyMjIsPJu14kEbVErrTV//Pc2Vu46BsCCrxMY2DmM0T0iSTiezcZD6WTmFwMwvFs7bjn/bC7q27FSkMzMK+a5L/dy7tkRXNK/Y/ny343syonsAhZ8ncCyrSmM6RHJuWe358tdx7lvYq8as8BHxEWw/K6xzF+6nR9+TeOV2cMJa1O5OTvI38FfZwyq9fX52W28+Lth3PreJpIz8k/rLxeNx2GzSU3bR5U1kZcF7TfffBMw14sHH3yQ1atXY7PZSE5O5vjx43Tq1Kna46xevZo777wTgEGDBjFoUMVn9qOPPuK1117D6XRy9OhRdu3aVWl9VWvXruXyyy8vv9PYFVdcwZo1a5g2bRpxcXEMGTIE8Hz7T6vHnDRpEvfddx8PPPAAU6dOZezYseXTqd54441MnTqVqVOnWjpHXUjQFrV6bfUBvth5jIcu7cvUQdF8ti2FZVtTeOX7Xzk7qi2X9O9IfGwEeYVO3lh7kHnvbqJHh2AmD+hEVEgA7dsGsGrvCTLyi3l4av/TvnHffVEvrhgaw5LNSSzdlMSahDQigwO4cWxcDSUywoP8eWX2cIpLSvGrZ7NzoJ+dt+aOwFlSKk3YTchuk5p2vXmoETem6dOnc88997B582by8vIYPnw4AO+//z6pqals2rQJPz8/YmNjq70dZ20OHjzIs88+y4YNG2jXrh1z5sw5o+OUKbutJ5hbe7o3w5+JXr16sXnzZpYvX85DDz3EhAkTePjhh1m/fj3ffPMNS5Ys4cUXX+Tbb7+t13mqkqAtPFq3P42/frGHSweexY1j4lBKcdPYs7lp7NkUOksIcFRuRr723G58vv0or685wIur9uN+P5qZI7rQL7r6Mc1d2wdx78Re3D2hJz8fPEVEW3+C/K39e9Y3YLuTgN20TJ+2JKL5ouDgYC644AJuuOGGSglomZmZdOjQAT8/P1atWsWhQ4c8Huf8889n0aJFXHjhhezYsYNt27YB5raebdu2JSwsjOPHj7NixQrGjx8PQEhICNnZ2ac1j48dO5Y5c+Ywf/58tNZ8/PHHvPvuu/V6nTUdMyUlhYiICK699lrCw8N54403yMnJIS8vjylTpjB69GjOPvvsep27OhK0RY2OZuZzxwdbODsqmL/OGHRaDblqwAYT9KYP6cz0IZ0pKdWcyi3iZG4hGXnFDOlSe3anzaY4r3v7BnsNonmTmrZvmzlzJpdffnmlTPJZs2Zx2WWXMXDgQOLj4+nTp4/HY9x6663MnTuXvn370rdv3/Ia++DBgxk6dCh9+vShS5culW7rOW/ePCZNmkR0dDSrVq0qXz5s2DDmzJnDiBEjAJM0NnToUMtN4QBPPPEECxYsKH+elJRU7TFXrlzJH//4R2w2G35+frz88stkZ2czffp0CgoK0Frz3HPPWT6vVbXemrOpya386ufwyTx2pGRyVlggncPbEBkcUG0CVlXFJaX84+sEvtp1nEJnCUXO0vJ+6k9uH1PrJCii6bWEW3M+9+VeXli1n4NPXtqEpfJ9cmtO39aot+YUviO30Mnv3viJpPSKvhp/u43IYH8iQwJo39afqJAAJvbrxIV9OmB3BfPDJ/O4Y/EWth7JYEyPSCLa+hPgsOHvsPGboZ0lYItGY7fZ0NqMQLDy5VKI1k6Cdgvyf8t3k5yRzwszhxLkbyclI5/kjAJSsws5mVtIWk4RW45k8NHGJKLDArlmRFc6hATwxOe7sSn456xhTBl4lrdfhmhFHHYTqItLSwmwNcxNWIRoySRo+5htSRk8/tku5p3fnYn9KoZOrUlI5f2fD3Pz2DguGxxd4/7OklK+3n2C938+xHNf7QPM7F0LrhlCTLvGu/2kENUpa+2Rfm0hrJGg3UwUOUvxd3jOXN6YeIq5b20gt8jJvHc3ct/EXtx2QQ+yC508sGQb3aPact/FvT0ew2G3MWlAJyYN6ERiWi77jmdzYZ8OkjUtvMLhCtoyVrvuWsP91lui+uaRSdBuBp7+Yg+LNxzh4z+Molv7ttVus25/Gjf+ayNnhQXy6ZwxLPh6H89+uY/dR7MJcNg4llXA0ltH1Wkmr7IbYAjhLWVBu0TuqV0ngYGBnDx5kvbt20vg9iFaa06ePElg4JnPkChB28s2HTrFy9//itZw26LNLL111GlDqVbtOcEt720irn1b3rtpJFEhAfz96iH0iw7lqRV7KNXwh/HdGdq19d2PWfg2u6uFR2radRMTE0NSUhKpqaneLoqoo8DAQGJiYs54fwnaXlRQXMIfl2wjOqwNf7ykN3d/+AtPLt/DI9P6l2/zwfrD/Om/O+h7Vijv3DCCdq5pPZVSzDu/O707hbJqzwnuuqint16GEGfMIX3aZ8TPz4+4OM8zBoqWSYK2F/39630cSM3lvRtHMqZnJNuTM3lz7UFGxkVwcf9OPLl8N2+sPcj43lG8MHNotbeKHNcrinG9orxQeiHqz17epy2zoglhhQRtL9lyOJ3XVx9g5ogujOlppuJ7YFIfNh5K53+WbuODDUdYvS+VOaNieejSvpIoJlokqWkLUTcSCZqI1prMvGJ2pWTx9a7j/M+SbXQMDeR/p1TMiuPvsPHizKEA/LA/jcen9+eRaf0lYIsWyy7Z40LUidS0m8CJrAKufu0nDqblli/zsyveuP4cQqs0eXeJCOLDeedRXFLKYAtzdQvhyxw2VyKaZI8LYYkE7UZWUqq5c/EWjmUW8L+T+9AlIojo8DZ0jQiq8V7RNd0JS4iWRvq0hagbCdqN7B/fJPDTgVM8+9vBzBh+5mn+QrREfnbp0xaiLqSztBH9sD+NF75N4MphMRKwhaiG9GkLUTcStBvJiewC7lr8C92jgnn8N/1r30GIVqisT1tq2kJYI83jDWRNQiqvfn+ArIJisgucpOUUUlxSyvs3jSTIX95mIapTXtOWRDQhLJFo0kCeWbmXpPR8BsWE0a19W0ICHVw68Cx6dwrxdtGEaLYc0qctRJ1I0G4AO1My2ZaUySOX9WPOaJlaUAirJHtciLqRPu0G8NGGI/g7bPxmaGdvF0UInyIzoglRNxK066mguISPtyQzeUAnwoOqH3ctRHOhlJqklNqrlNqvlJpfzfp7lVK7lFLblFLfKKW6ua27XimV4Pq5viHKU1bTLpY+bSEskaBdT1/sOEZWgZOrz+ni7aII4ZFSyg68BEwG+gEzlVL9qmy2BYjXWg8ClgBPu/aNAP4MjARGAH9WStX7XrCSPS5E3UjQrqcP1h+mW/sgzo1r7+2iCFGbEcB+rfUBrXURsBiY7r6B1nqV1jrP9fQnoGyCgUuAr7TWp7TW6cBXwKT6FqgsEU36tIWwRoJ2PRxIzeHng6e4Kr4LNlcznxDNWGfgiNvzJNeymtwIrDjDfS2RPm0h6kaCtkVZBcXMeWs9z6zcQ2p2IQAfbUzCblMy25locZRS1wLxwDNnsO+tM1OIAAAgAElEQVQ8pdRGpdTG1NRUj9vKjGhC1I0M+bLo71/t4/t9qXy/L5U31hxkxvAYVu48zgW9O9AxNNDbxRPCimTAPfkixrWsEqXURcD/A8ZprQvd9h1fZd/vqjuJ1vo14DWA+Ph4j9FY+rSFqBupaVuwKyWLf61LZNbIrnx97zguH9qZf29MIi2nUBLQhC/ZAPRUSsUppfyBa4Bl7hsopYYCrwLTtNYn3FatBC5WSrVzJaBd7FpWL1LTFqJupKZdi9JSzcOf7CA8yJ/7L+5NeJA/T105iHsm9mLL4XQu6tvB20UUwhKttVMpdTsm2NqBhVrrnUqpx4CNWutlmObwYODfSimAw1rraVrrU0qpxzGBH+AxrfWp+papvE+7RBLRhLBCgnYt/rMlmY2H0nl6xqBK47A7hgYyacBZXiyZEHWntV4OLK+y7GG3xxd52HchsLAhy2O3S01biLqQ5nEPMvOLeXL5boZ1DWfGMEk2E6KhSfa4EHUjNW0PnvtyL+l5Rbxz4wgZ0iVEI5A+bSHqRmraNcgvKuHDjUeYMTyG/tFh3i6OEC1SWfa43JpTCGskaNfg+32pFBSX8pshchMQIRqL3aZQCkpkRjQhLJGgXYOVO48RHuTHiLgIbxdFiBbNYVPSPC6ERRK0q1FcUso3u48zoU9HHHZ5i4RoTHabkkQ0ISySiFSNnw6cJKvAyaQBnbxdFCFaPIfNJjVtISySoF2NL3YcI8jfztiekd4uihAtntS0hbBOgnYVpaWaL3cdZ3zvKAL97N4ujhAtnunTlkQ0IayQoF3FliPppGYXckl/aRoXoilITVsI6yRoV7Fy53H87IoL+sic4kI0BYdNUSzjtIWwRIK2G601X+w4xqjukYQG+nm7OEK0Cna71LSFsMpS0FZKTVJK7VVK7VdKza9mfVel1Cql1Bal1Dal1BTXcn+l1FtKqe1Kqa1KqfENXP4GtedYNodP5UnTuBBNyE+yx4WwrNagrZSyAy8Bk4F+wEylVL8qmz0EfKS1Hoq5R+8/XctvBtBaDwQmAn9TSjXb2v2KHcdQCib26+jtogjRapg+bUlEE8IKKwF0BLBfa31Aa10ELAamV9lGA6Gux2FAiutxP+BbAK31CSADiK9voRtDkbOUxesPM6ZHJFEhAd4ujhCtht2mZO5xISyyErQ7A0fcnie5lrl7BLhWKZWEuVfvHa7lW4FpSimHUioOGA50qXoCpdQ8pdRGpdTG1NTUOr6EhrFsawonsgu5aezZXjm/EK2VQ/q0hbCsoZqqZwJva61jgCnAu65m8IWYIL8RWACsA0qq7qy1fk1rHa+1jo+KimqgIlmnteb11Qfo3TGE82VCFSGalF36tIWwzMr9tJOpXDuOcS1zdyMwCUBr/aNSKhCIdDWJ31O2kVJqHbCvXiVuBKsT0th7PJtnfzsYpeS+2UI0JYeM0xbCMis17Q1AT6VUnFLKH5NotqzKNoeBCQBKqb5AIJCqlApSSrV1LZ8IOLXWuxqs9A3k9dUH6BgawLTB0d4uihCtjl1mRBPCslpr2lprp1LqdmAlYAcWaq13KqUeAzZqrZcB9wGvK6XuwSSlzdFaa6VUB2ClUqoUUzuf3Wiv5AztSsli7f40HpjUB39Hs01sF6LFctgURU4J2kJYYaV5HK31ckyCmfuyh90e7wJGV7NfItC7fkVsXG+sOUBbfzu/G9nV20URolWyy/20hbCsVVctj2bms2xrClef05WwNjIDmhDe4Ge3SZ+2EBa16qC9cO1BNDB3dKy3iyJEqyU1bSGsa7VBOyOviPd/Psxlg86iS0SQt4sjRKvlkBnRhLCs1Qbtd348RF5RCb8f393bRRGiVZOathDWtcqgnVfk5K0fDjKhTwf6dAqtfQchGpqWIFVGxmkLYV2rDNofbjhCel4xf7hAatnCC9a/Ds90h9RmN8+QV9htNpl7XAiLWl3QLnKW8vrqA4yIjWB4twhvF0c0tZQtUOL0zrm1hu+fhuX3Q95J2Pu5d8rRzEhNWwjrWl3QXrY1hZTMAm6VWnbrc3QbvDbeBM2mVloKKx+EVX+BwTMhsjcc+L7py9EM2e0yI5oQVrWqoF1aqnnl+1/pe1Yo43s1/Y1JhJftdc0PtOkt2PJe053XWQSf3AY//RNG/h6m/xO6XwCHfwJnYdOVo5lySCKaEJa1qqC962gW+0/kcMPoWLkxSHNydCus+r/GT87atxI6D4e48+GzeyHll8Y9H0BOKrwzDbYugvEPwqSnwGaDuHHgzIekDY1fhmbOYbNRIn3aQljSqoL2juRMAM6Jlb7sZmXzO/D9X+HAd/U/VmZS9Qle2cchZTP0ngJXLoS2kfDRbMg7Vf9z1uToVtMcn7IFrnwTxj8AZV8WY0eDskkTOeZ+2lLTFsKaVhW0d6ZkERLgoKtMplK7vFPw7uXw6d2Nn7iVutf8/vHF+h/r33Ph7SmnNzsnfGl+95oEwVFw1TuQdRT+c7Pn13emtf89n8OblwAabvgCBs6ovD4wDKKHwsHVZ3b8FsQuiWhCWNaqgvaOlEz6Rodis0nTuEdZR+GtKSagbHrL1EiLCxrvfKl7wREI+7+G4/W4c+vxXZC0HnJTYefHldft+wJCY6Bjf/M8Jh6mPGPOWd3rO74TXoiHr/5U93JoDZ/fB5E9YN53JjhXJ24cJG+Ewpy6n6MFccitOYWwrNUE7ZJSze6jWQyIDvN2UZq3Uwdg4SWQeQRmfwxTnjUJXO/PgMLshj9f3inIPQHn/gH8gupX297yLtj8oF0s/PRyRS3ZWQi/roJel1Q0TwPEz4XJz5z++nYtgzcmwskE2PRO3ZPFju+A7KMm6Sy4Q83bxZ0PpU44tK7y8iMbWtUYbrtNUapNoqgQwrNWE7QPpOZQUFxK/2iZAa1Gx3fBwkkmeF2/zASVETfDFa+bwPKvyyBxLRTnN9w501zBqet5MPRa2PaRqenXlbMQtn4AfafCqDvg6C8VSV6Ja6E41wTtqkbOq/z6vn7U1Lw79oPpL0FhJuz/pm5lKWuK73GR5+26ngv2ADjo1q9dmANLb4Alc1vNrGkOV8tXSSt5vULUR6sJ2jtTsgAY0Flq2tXKTDJ92MoGc1eYLOsyg66CaxbBiT3w9qXwZBd4fQJ89bCpmddH6h7zO6oXnHsr6BJY/1rdj7PnM8hPh2HXwaBrICAMfn7FrNu3EhxtzJeQ6gy6Cq5533xpWfscDJkF138Gg66GNhGwY2ndypLwNXQaBCGdPG/n1wa6jKgctL9+BDKOwKV/q9wq0ILZbeYyJP3aQtSuFQXtTAIcNrpHtfV2UWqXn9G4Wc1VFWbDoquhKBeuXQod+py+Te9JcN9umPkhjLod7H7w4z/hheEm+evo1jM7d+o+E1DDukLE2dD3Mtj4Zt37eTe/Y44RNx4CgmHYbNj1CWSlmP7ss8eZIFmT3pPNl5Ur3zQ1bL9A8xr7TTfN50W51sqRnwFHfoaeE61tHzcOjm03f++Da2DD6+bLS9dzre3fApTVtItLpF9biNq0mqC9IzmLPp1CcNib6CWvec4EtbpyFsFbk+HDaxu+TNUpcZqge2I3XPV2RaJWddq0M8H7okdMRvTd2+G82yHhK3j1fPjourpnmqfugcieZuwywKg7oSCzbpOfpCea4WLDZlcc55yboLQEVjwAGYeqbxqvKma4yfJ2r+EOuBKK80xt3YoDq0xrQQ+LQfvsceb3vi9g2e3QLg4uPIPkNx9mL2sel5q2ELVyeLsATUFrzc6UTKYOjm6aE5Y4TdAuzoO4sdBpoPV9f3oJTuwCZTc14ICQyutLS2DT26bWGBZjfkJjwOFfc1myU0zzd2Yy5BwzwTcsBsK6wI8vwf6vYOqC2vtgqwo9Cy5+HMbeZxLIVj8DUc/ABf9r/Rhp+0x/dpmYeOg6ClY/Df0vh5COp++jdeXAuuU906w/5HcVyyLiTO159zLzvKeFoF2dbqMguJNpIh9wRe3bJ3xthnPFnGPt+NHDwD8Elv8RinJgzufg37qGJDrs5m8pY7WFqF2rCNpJ6flkFTibLgnt2FYocmUif3Yv3LCyogboSfoh+O6vJvs5PREO/Qi9Lq68TcKX8Pm9lZe17QA3fwPhXSsvL8w2WdCpuz2fd9SdJpP6TLUJhwsfMn2xq582U3Raad4tzDFZ6lHXV14+9e/w2jj4760wa0nl9273Z7D0JtPnPnAG9JkKW96H7hPMFxF3I28xTdudBkJY5zN7bTY79P8NbHzLtAAEesiJ0NoMIet+IdgtfrTsDvPFIGEljJgHsWPOrJw+zCF92kJY1iqax3emmJnQmmy418E15vfEx8y44S3vWNtvhWvGrFlLwO4PiWtO3ybhS/APhts2wHXLYNoLpka/7M7Ts42/fsQ0P1/8F7j2P2afBw7Bnb+YRKvfvAJXvAEXPVqvl1tuyjPmi8PSm02Aq01Z5nhUlT70Dn3gkr/Ar99UJJOBCYhL5ppadM5x+OxueLanaUkYdt3px48bZ4L6OTef+WsC00ReUgh7lnve7th205JhtWm8zNBZEDsWJvz5zMvow8r6tKWmLUTtWkVNe0dyFnabonenkNo3ronW8Ou3cNZgMwWmJ4lrzF2cRt0J+76Er/5sgkfZfnmnTN9nl3MraoB7Pod9K2Di46aPN+ac04O21qb5NW6cybaO6mWWOwvNnas2vwPDXbXWg2tgwxtm/POo2ysfp024CXwNLTDUfAlYeIlpYbjyDc8Z0GUzoUX2Pn1d/I1mqNXXfza1z8IsWDwLonrD9Z9CYDgc2wbbl0D2MTPTWVVKmazw+oo5xyS57VgKQ2bWvJ3VoV5V9Ztuflqp8j5tmX9ciFq1iqC9MyWTHlHBBPrZPW94dBukH6z+Avrrt/DeFdA2ymQX15TYVFJs7t406GoTNC79G7wyGr78k+nr/fElE1yL8wBlmkYHXAFrF0CHfiZzGEzNa/XTlZtkU/dC5mEYW6V5PP5Gkyn95UMmYLQJ915SU5dzYPz/wqonzBecc281WdjVSd1jJkOp7guEUjDtRXh5lElwy02F8G4w+7+mTx7M8c8a3Hivxb0sAy43f7vEtWZoWWaSGa8+dLaZFhVMS8BZg6vvhxc1qujTluxxIWrTKprHd6Rk0b+zhf7sT++Ef88xN3hwV1pqanxhXSG4Iyy6yszJXd0woJRfTEJR3FjzvEMfM9nH1kXw/FBT++33G1NbvOBBE4w+v8/07U79e0WAix0DutT0a5fZ/5X5XXU4kc1mmslLnfDpXWaCkPRE8+XCG0lNY+81/bpf/QmeHwY/v1r9e5W2D9p3rzmot20Pl79svki1jYTr/lt7K0djGXCleX/fvtRk9n8xH755FF4YButehNw0OLK+7k3jQrLHhaiDFl/TPpFVQGp2If1r689O3uwK1go+uwdu+sYkIQHs/I/pr7zidVML//YJWPeCab6+8SsIcrtrWKLrBhDd3BKKzv8fM3FH++6muTq8i1kedz6c/0fXON2TlZO3Ys4xs2UlrjHDrMAMrYrqe3rCFZja6kWPwIr/Mc9H3GLuJOUNNjvMWmqSq9YuMGX67im4+t3KiVape2rPrO9+oRk/HdHduzXYswbDzMUme78s8z7vJKx8EL78f7DmWTPUq+fFtR9LVCJ92kJY1+Jr2uUzodWWOb7xTTP39dTnTPDeuNAsdxbBt49Dx4EwYAY4Aswwp9n/gZO/wk9VxmInrjWBtazJFExtd9ZHMOnJioBdRik4a5DJuHbnF+iaLcv1JaAw20y16WnSjnNuNl8E2veAi7yc1GSzmSFXN6402fP+wWYGtbJkueIC0xpQXX92Vd1GNY8m596TzTSp0UNMK0BUL7h2CfzuIzNzWmjnyjPJCUvKZkRzSp+2ELVqBUHbZDH38xS089Nh+1IY+FsYPtcken3zuLkH86a3TXC56JHKQ4+6X2gu4D+/BgXmiwHOItOfXdY0Xl+xY00tPD/dBO/SYs9B22aDaz+G368F/2Y081vXc2H0nZC8ybw/ACf3m+b/KAtBu7nrdQnctt78WB3qJcpV1LSlT1uI2rT4oL0jOYvY9kGEBNbQbwqw9UNw5sM5N7qSx54zz5ffB9//1QTPHhNO32/MveaGEhveMM9TNpsEs9gGCtpxYwFtatgJX5naapdaxj/bHZ6n6/SWIbNMbbTsLl5prszxlhC0wbzvAcHeLoVPkj5tIaxr8UF719Esz/3ZWpum8M7DKzKRI3vAmHtg96eQl2Zq2dUNXeo8zNS4f3wJivIqhmh1a6C+5M7DzbzcB9eYoH32+JpnPmvu/IPM1KJ7Poe0/a7hXso05YtWTWZEE8K6Fh20C4pLOJKeR8+OHmpAiWtNrS/+xsrLx9wLHQfA4Jlmas2ajL3fBPYt75ng2nGA6e9sCI4A6DoSti2GrCTrN6ForkbcbCaN+eklE7TbxTbPVgHRpGRGNCGsa9EdcIdP5aE1xEW69e9mHIag9hV9vhvfNBN1VJ1X2i8Q5n1fkUFek26jTJP1D/8w2cTD5zToayB2jLkZBvj+cKLgDjD4avhlEQRFQqcB3i6RaAbskj0uhGUtOmgfSDVjg8uDdnqiGSuNMk3hXUaYJvARt1Rf47OSVKSUuWHGot+a5w2VhFYm1nUP6A79z3z+7ObkvNvN5DJZSTDwSm+XRjQDjvI+bUlEE6I2Lbp5PPGkCdqxZUE7eZPJWB46ywzv2vQ2oOp3swwwzdadBlI+w1lD6jzMzMLWb1rDHtdbonpXTDlqZbiXaPHKa9oy5EuIWrXomvbB1Fwig/0JLcscP7bdTJs55W8moctZBAUZptm2PpQyM5KlbKmYYrOh2P3gjs3mS0ZLMfY+M9Nbl5HeLoloBsoS0aRPW4jateygnZZbuT/72HZzR6myDGyHf/0DdpnooeanMQQ20S1Fm0qXETD/kOebiYhWQ2ZEE8K6Ft08fvBkLrHt3YP2Dkl+ai4kYAuX8hnRpE9biFq12KCdXVBManYhcVGuoJ1zwtzruLa5roUQTcohfdpCWNZig/ahk3kAnF3WPH5su/ktQVuIZkX6tIWwrsUG7QNpVTLHy4J2R2keF6I5kXHaQljXYoP2QdcY7fI+7WPbze0U3W+jKYTwOpkRTQjrWmzQTjyZS3RYIIF+rhnNju+QpnEhmiGpaQthXYsN2gfSciuS0IrzIW2fNI0L0QzJjGhCWNcig7bWmoOpORVjtE/sMjOhSU1biGZHatpCWNcig3Z6XjFZBc7K/dkgQVuIZqi8pi1DvoSoVYsM2gfTcgA4O8otaAeEQng3L5ZKCFGdspp2sdS0hahVCw3aZox2RU17h+nPtrXIlyuET1NKYbcp6dMWwoIWGcUOpuVgtym6RARBaalkjgvRzDlsSvq0hbCgRQbtxLQ8ukYE4We3QfpBKMqROceFaMYcNiV92kJY0CKD9oG0XGLbu25lKUloQjR7dqlpC2FJiwvaWmsS03KJiww2C45tB2WHqL7eLZgQokYOu01mRBPCghYXtI9nFuAozqZXWAkUZMLRXyCqN/gFertoQogaSE1bCGsc3i5AQ9Mr/sj2wHfhW8wPwKBrvFkkIUQtHJI9LoQlloK2UmoS8A/ADryhtX6qyvquwL+AcNc287XWy5VSfsAbwDDXud7RWj/ZgOU/TZvkdews7Ubn8TcQ3sYPUNBnSmOeUghRT1LTFsKaWoO2UsoOvARMBJKADUqpZVrrXW6bPQR8pLV+WSnVD1gOxAK/BQK01gOVUkHALqXUB1rrxAZ+HYazkNCcRBYxjd+PvwtckzYIIZo3h03hlOxxIWplpU97BLBfa31Aa10ELAamV9lGA6Gux2FAitvytkopB9AGKAKy6l3qmqTuxUYJaW17YpOALYTPMJOrSNAWojZWgnZn4Ijb8yTXMnePANcqpZIwtew7XMuXALnAUeAw8KzW+lR9CuzR8Z0AnAru2WinEEI0PIfNhlP6tIWoVUNlj88E3tZaxwBTgHeVUjZMLb0EiAbigPuUUmdX3VkpNU8ptVEptTE1NfXMS3F8B4X4UxgSe+bHEEI0OYddatpCWGElaCcDXdyex7iWubsR+AhAa/0jEAhEAr8DvtBaF2utTwA/APFVT6C1fk1rHa+1jo+Kiqr7qyhzfCe/0oXwYBneJYQvkWlMhbDGStDeAPRUSsUppfyBa4BlVbY5DEwAUEr1xQTtVNfyC13L2wLnAnsapuin08d3srMkhvAg/8Y6hRCiEUifthDW1Bq0tdZO4HZgJbAbkyW+Uyn1mFJqmmuz+4CblVJbgQ+AOVprjck6D1ZK7cQE/7e01tsa44WQk4rKPcHu0q6uoV5CCF/hsNkke1wICyyN09ZaL8ckmLkve9jt8S5gdDX75WCGfTW+EyYJbbfuSh+paQvhU6SmLYQ1LWcaU1fm+N7SLoQHSU1bCF/isCvJHhfCghYVtAsDozhFKO3aSk1bCF8iM6IJYU0LCto7yAztBUA7qWkLUS2l1CSl1F6l1H6l1Pxq1p+vlNqslHIqpWZUWVeilPrF9VM1GbVeZEY0IaxpGTcMKXHCiT2ciDE3BpHscSFOZ3FK4sPAHOD+ag6Rr7Ue0hhlkz5tIaxpGUH71K9QUkhSgJm3RbLHhahW+ZTEAEqpsimJy4N22X0BlFJN2sHssMuMaEJY0TKax4/vACDR1o2QQAcOe8t4WUI0MCtTEnsS6Jq58Cel1G8asmAOqWkLYUnLqGkf3wXKzr7SaNoF5Xm7NEK0VN201smuqYi/VUpt11r/WnUjpdQ8YB5A165dLR1YEtGEsKZlVEmP74TIXqQVKElCE6JmVqYkrpHWOtn1+wDwHTC0hu3qPC2x1LSFsKblBO2O/cnIK5IkNCFqZmVK4moppdoppQJcjyMxkynt8ryXdXabTWraQljg+0G7IBMyD0PH/qTnFUlNW4gaWJmSWCl1jusWu78FXnVNQQzQF9jomqp4FfBUlazzepGathDW+H6f9nHXdaPjADJyi6WmLYQHFqYk3oBpNq+63zpgYGOVy25TFJdI9rgQtfH9mrZrzvHiyD5kFzppJ0FbCJ8jNW0hrPH9oJ1xGOz+ZDhMwovMOy6E77HbJXtcCCt8P2hnJkNoNJkFTkCCthC+yM9mk5q2EBa0gKCdBGFdSM8rBpDmcSF8UNk0plpL4BbCE98P2lnJENqZ9NwiQIK2EL7IYVMAUtsWoha+HbRLSyArBcI6k+GqaUvzuBC+x243QVv6tYXwzLeDdvYx0CUQFkN6nqumLffSFsLnSE1bCGt8O2hnuWZgDI0hPa8YP7uirb/du2USQtSZ3WYuRVLTFsIz3w7amUnmd1jn8ilMlVLeLZMQos7KatpOmWBFCI9aSNCOkSlMhfBhdmkeF8IS3w7aWcngHwKBYaTnyRSmQviq8pq2BG0hPPLtoJ2ZBGGdAciQmrYQPsthN5ciqWkL4VkLCNrm3gbpecUyRlsIHyU1bSGs8e2g7ZpYRWst99IWwodV9GlLIpoQnvhu0C4ugNxUCIsht6iE4hItzeNC+CipaQthje8G7bIx2mEx5VOYymxoQvgme/mQLwnaQnji+0E71H0KU2keF8IXOewy5EsIK3w3aGdW1LQz8uVmIUL4MpkRTQhrfDhouyZWCY12uy2nNI8L4YtkRjQhrPHdoJ2VBEGR4NeGjLyyPm2paQvhi2RGNCGs8d2gnZlcPrFKeq7cllMIX+Ynt+YUwhLfDdpZyRDWBYD0vCJCAhz42X335QjRmpX1aUtNWwjPfDfKZSZBaMUUpuFtpZYthK+ScdpCWOObQbsgCwqzKprHZQpTIXyazIgmhDW+GbTdJlYBZApTIXyc1LSFsMY3g3b5cC/3m4VI87gQvkqyx4WwxreDdnnzeJE0jwvhwxxlk6vINKZCeOSbQTsrGZQdgjvhLCklu8Apw72E8GH28iFf0qctvODIeji+y9ulsMQ3g3ZmEoScBXYHGflls6FJTVsIXyV92sJrSktg0VWwcBKc2OPt0tTKd4N2WMVwL5CJVYTwZdKnLbwmeRPkp0NRjgneOaneLpFHvhm0s5LLM8fT5Q5fQvg8P+nTbn1y02D5H2Hdi94tR8JXoGww69+QcwIW/w6KC7xbJg98L2hrbaYwDS2bwrTsDl9S0xbCV9nl1pytR2kJrH8dXhgO61+Dn1/xbnkSvoSYEdBjAlzxKiSth0/+YGJNM+R7QTs3DUoKK8ZoS5+2ED5P+rRbiYzD8PoFsPx+6DQQhsyCzCNQmOOd8uScgKO/QM+LzPN+0+GiR2DHUti+xDtlqoXvBe2ssuFeJmhnuYJ2aKDUtIXwVTIjmg/76WXY9La1bTe+Bcd2wIyFcP2n0HuyWZ62r9GK59H+b8zvHhMrlo26C2x+cHyHd8pUC98L2uHd4Kp3IeYcoOKbuZ9DebNUQoh6sCupafus9a/BlvesbZtxCMK7wIArQSmI7G2Wp+5tvPJ5kvAltO0AnQZVLLPZTKJz5hHvlKkWvhe0gyKg3zQI7gBU9IGVfVMXQvgem01hU9Kn7XNKSyDjCORazLjOOALhXSueR8SBzQFpXgjaJU749VvoOdEEandhXSom8aqr9a/DyV/rX74a+F7QrqIs29Sv6psuhPApDpuNYske9y1ZKVBabH2YVMZhCHML2nY/aN/DOzXt5E1QkAE9Ljp9XVgX8wWjrrJSTH/96mfrX74a+HykKyktRSnzTV0I4bvsNiV92r4m45D5XZwLRbmety0ugJxjlWvaAJG9vBO0E740Q726X3D6uvAukH0UnEV1O2byZtexV5pWiEbg80G7uFSXZ54KIXyXw6akT9vXpB+qeJxzwvO2ZXdnDO9SeXlUH0g/CM7Chi1bbfZ/BV1GQpt2p68LiwE0ZKfU7ZjJm8zvvJOQtKHeRayOzwftklIt/dlCtAAOu5I+bV+T4Ra0a+vXLtu2ak07qjfoUji5v2HL5kn2cSaWAn8AACAASURBVDi6tfqmcTDN41D3JvLkTRDR3fTT711evzLWwOeDtrNEl98hSAjhu+w2m9S0fU16YsXjWoO2KwBWF7ShaZvI939tfvecWP36sjLWJRmttBRSfoG48yF2DOxdUb8y1sBStFNKTVJK7VVK7VdKza9mfVel1Cql1Bal1Dal1BTX8llKqV/cfkqVUkMa8gWUlJbisEtNWwhf57ApSiQRzbekH4J2ceZxbc3jGYfN3RlDoisvb98DUE0btLd9aMrhPtTLnWvGzToN+zr1KxRmQufh0GuyGXveCFnktQZtpZQdeAmYDPQDZiql+lXZ7CHgI631UOAa4J8AWuv3tdZDtNZDgNnAQa31Lw35ApzSpy1Ei2CXPm3fk3EIYuLN41pr2odNMLQ7Ki/3awPtujXdsK8j6+Hg93DurWaseHX8As347boE7bL+7M7Dofck87gRattWatojgP1a6wNa6yJgMTC9yjYaCHU9DgOq672f6dq3QTlLpE9biJbA9GlL9rjPKC4wGdbte0JgWO017cwjpzeNl4nq03Q17e+fhjYREH+D5+3CYurWp528Gfzamub+drHQoR/s+6JeRa2OlaDdGXAveZJrmbtHgGuVUknAcuCOao5zNfDBGZTRI1PTlj5tIXyd1LR9TMZh87tdN1MrtVLTrpo5Xiayl0lEK3E2bBmrStlissbPuw0Cgj1vG17HCVaSN0H0ELDZzfPek+HQOnPbzwbUUNFuJvC21joGmAK8q5QqP7ZSaiSQp7WudjJXpdQ8pdRGpdTG1NS63ctU+rSFaBkcNiW35vQlZdng7WLNDJWegrazyEw84qmmXVJUORu9Max+1rQKjJhX+7Zls6JZuduXswiObYPOwyqW9ZoMugQSvj7z8lbDStBOBty/HsW4lrm7EfgIQGv9IxAIRLqtvwYPtWyt9Wta63itdXxUVJSVcpdzypAvIVoEyR73MWWZ4+HdoG2U5+bxrGRAewjaZRnkexqyhJUd2wF7PoORt0JgaO3bh3UBZ765s2RtTuw0Xzqi3YJ25+HmfWngoV9WgvYGoKdSKk4p5Y8JwMuqbHMYmACglOqLCdqpruc24CoaoT8byoZ8SdAWwtc5ZEY035JxCOwBENzRBKdcD0G7rCk9zEPzODRuv/aaZ8E/GEbeYm37sqb8qslov34Ln99nhniVcU9CK2OzQa9LzJ3E6jqzmge1Bm2ttRO4HVgJ7MZkie9USj2mlJrm2uw+4Gal1FZMjXqO1uVtCucDR7TWBxqs1G5MTVv6tIXwdQ679Gn7lPREU3O22UzzeEFmzbOaZdYwRrtMYKgZgtVYQTstAXb+F0bcbG46ZYXr9s+nBe0Nb8KGN2Dz2xXLkjdDUOTpr6/3FDMM7PC6My56VY7aNwGt9XJMgpn7sofdHu8CRtew73fAuWdeRM9KSkvxkz5tIXyeqWlL0PYZ6YdMfzaYmjaYpuSwqnnKuMZo2yrGP1cnqlfjDfva9wWgYYTFWjZUtAq4J6NpDYd/Mo+/fgT6XAbBUSZodx52+hCys8fD5a/BWQ03PYnPV1GlT1uIlkGyx31MxiGTOQ7lt0qusYk84zCEnAUO/5qPF9UHUvdVbnZuKMe2m5p86FnW92nTzgzhch/2dfJXyEuD826Horz/396dh0dVnQ8c/57sZCNkISwhJCwBwhYCgrIji2gVKqKAqFXrUtdqq9W27q39aWutSq3VqlA3EFeogguCCorse8ISIEAIBEhCCCEJmZnz++POJJOQlUwyc2fez/PwTHLnzp13Apc357xnga8egfJioxbv3DXuEBQGA2dAm6jmfwa7RrW0PZnUtIXwDgF+fpRWtMzOSMLFSguN7vAoe9J2tLTr2qKz5j7atYlNMXYLO3W47qlh5+voNujQv2mvUco+7cspaR9cbTwOuh4CQow6ebskQNeetFuA6VvasmGIEN5BWtoe6lQufHgznCmoOlboNN0LnLrH62lpN5S043obj67uIq8oM2rlTU3aYJ/25ZS0D/1ktMBjU2D0A8YvLd89YzznPHK8BZk+aVtsNgL9Tf8xhPB5MnrcQ+35GrZ/BFucZu1WztGu2T1eS0vbajFaz3WNHHdoqY1Djmca86XPK2knVK9pH1xjbOfp52csv3rZc8bxqK4QFuOaeBtg+mwnLW0hvIO/LK7imfL3GI+b3q1aaMTR0nZ0jweFGfXf2rrHi3ONpNlQSzssFiITYN+3Lgm70tFtxuP5JO2oLsbe2GdLjEF2+Xsg0WlcdcokuPBOGHyjS0JtDNPXtCukpi2EV5ApXx7KsVPVsR1wZDN0GmS0tEPaVh9gFV7HXG3HHO3G1KkHXAM/vACnjjRt0Fh9jm4z5mc7diNrisoR5IerfnnpUmMy1OT/a158TSQtbSGER/D385MpX54oPwuSRhkLqWx61zhWmF1Vz3aoa1W0yn20uzb8XmmzQdtgqwvX4jq6DeL7Gl3aTVWZtA8ag9D8g4xfWtzI9EnbYrPJhiFCeIFAP4VFatqexWqBgv3G9pt9LodtHxgLqBQeODcJ17VpSOVqaAkNv19sD0i8qHpXfHPYbMbypefTNQ5VvQMnDxn17E6DjG073cj02c5q07JhiBBewN9PYZWatmcpOgi2CojpYbSCy07Czs+NRNyuRtIOj6s7aYd3gIDgxr1n2myjKzpnXfPjP3kAzhaff9IO7wDK3+htyN1kDEJzM9MnbVlcRQjvIDVtD3Qiy3iM6WGs7hXZGVY9D9byWrrH2xuDtmw15toXNWK6l7O+P4fAUNj0TjMCt2vOIDQA/wDjM2cuNn55Sbyo+TE1k/mTtgxEE8Ir+Msypp4n35G0exr7RA+cWZUIo5KqnxsWZ9Sjz+RXP96YOdrOgiOg75Ww/WNj1bHmOLrNWD61fer5X6NtQlUXv7S0m082DBHCOwTI1pyeJz8LQqKqNtlIm131XG3d41B9MJrNasxzbuoKZ2mzjW7tzJobSjbR0W3GQiiBbc7/Go7YY1NabS52fUyf7WTDECG8g7S0PVB+ltE17tgII6Z7VRdxzcVSwmpZYKX4KNgsTWtpA3QdbkzR2vSOMRhu//ew9CH48Jdgraj9NUe2GO/n7HyWL63JMYDOA1rZ4AXztKWmLYR3CPBTVFhl9LhHyd8LSSOrH5vwJGSvPHcUdW2rojm615uatJUyWtsr/gx/624MgHMYed+5iVhrePtKY1OQ21aAf6Cx7OqpHBckbfsvJx5QzwYvaGlLTVsI7yAtbQ9z9oyR9GJ6VD+eOMxYd7umsFjj0bl7fO9y8AuAhKFNf//0640pVr0uhRnvwC3fGMePZZ577qlco5aetw1+nGMca+4gNIfEi4x10btf3LzruIjpW9pWqWkL4RUC7BuGaK1RNfclFq2vwL4SWmyP+s9zCIkyFh9xXhVt9xfQdQSERDb9/SM6wG3fVn1vrQC/QMjbce65jmMxPeDbZyB1alXSjm9m0m7fG+5a07xruJDps51FatpCeAXHL9/S2PYQ+U7TvRpDKfuqaPbu8YL9xj7TvS51TTz+gcZgsGMZ5z6Xt914nPmesWXm4nuNGnd4h6oBcl7C1EnbZtPYNFLTFsILOBZJklXRPIQjaUd3a/xrwpwWWNnzlfGYconrYopPhbxakvaxDKP2HNcLJv0JDqyCHZ80v2vcA5k6aTumh0hNWwjzc9zHUtf2EPl7jYVFgsIa/5rw9lXd47uWGi3jpiT9hrRPNerspSerH8/bUTUXO/0GY610W4UkbU/juLmlpi2E+Tl6zGSutodwTPdqCkf3eHkxZK+ClMmujSm+r/HoPBjNchZO7K56Tim44kVom+gxg8dcydTZztGNJjVtIcyvsqUt64+7n9ZwYs/5Je2S48aocVuF65N2+z7Go3Nd+8RuYy64I2mDMZ/8/m2QPMq17+8BTJ20q1rakrSFMDt/f+O/I2lpe4AzBcbc6KYm7fD2RrLe8r4xmtzVC5K07QLBkdWTtmPkuHPS9mKmTtpS0xbCe0hN2432fVd9KlVTR447OFZF2/0F9JxobLjhSkoZrW3nwWh5242pZk2N1aTMnbStUtMWwtSWPw1LHwaqesxkVbRWtukdeGsqzLvcWCccnJJ296Zdy7HAira6vmvcoX0qHNtRtd923g5j1Lh/YMu8n4cxdbZz1LSlpS2ESR3PhL3GSlfS0naDjW/DoruNtb6tZ+GDm4yBXflZxkImUV0bvoYzx1Kmyh96jHd9vGB0g5cVGauggdFV3t43usbB5EnbcXMHyEA0IcwpvAOczgNk9Hir2/g2LL4Huo+D6z6CKXMgZy0sexzy90B0ctO7tx3d44kXQZt2ro8ZqqZ2HcuEknwoPuIz9Www+TKmFhmIJoS5RcQbraaKUgLtA9Gkpd0KMhZXJeyZ7xlbV/abBofWwE//gsAw6Dam6dcNjTbmZqdd6/qYHSpHkO+AgCDja0na5uCoaQdITVsIcwrvYDyezsPfz9g1SlZEc3JgtTEC29X/x21baGw56UjYDhP/BDnr4fD6ptezAfz84e51rouzNqHRENHRGIzmH2wc86Gkbeps57i5paUthElF2JN2cZ7UtGs6shXmToYt8xt3/v9+DZvfa9y5+Xshvl/1hA1Gy/XqeUYXdLexTQi2lTkGo+Vth9AYCI93d0StxtRJ23Fzy+IqQpiUY+DS6aO+UdPe8j4839cY7NWQ4zuNx8zFDZ9bXgwb/mvUqRtis0HBvrpb0lFd4M7V0GNCw9dyl/hUOL7b2BQkvq8xFcxHmDppS01bCJMLd25p+0BNO3ejsXZ2wb6Gz823b425d4WRlOtzZAugIXeTsYVlfU4dBkvZ+XV/e4r2fcFaDke3Gj0GPsTcSVtq2kKYW1gsKD97Tdve0vbmZUwd05Qcrej65GcZU6es5ZC1rP5zD28wHi2lte83XfO6YO7FSOJTq75un1r3eV7I1NlOatpCmJyfvzFN6PRR39ias/io8Xhid8PnFuyFpJEQGguZn9V/7uGNxvKeADkNDAQrsLfgzZy0Y1OMX/bApwahgcmTttS0hWgapdRkpdQupVSWUurhWp4frZTaqJSyKKWm13juF0qpPfY/v3BZUBHxUJznGzVtR9JuqKWttdE9HpsCvS419qaurw6eu9HY0Sq8gzH6uz75eyEw1BiBbVaBbSC6u5G443q7O5pWZeqkLTVtIRpPKeUPvAxcCqQCs5RSNfsWDwI3Au/VeG008DgwDBgKPK6Ucs3qGeEdjJa2t+/yZbMZC4EAHN9V/7klJ6D8lNEa7nOF8fX+7+s+9+RB6JwOCUMabmnnZ9kTnsn/3+wyzNgvOyjU3ZG0KlMnbavUtIVoiqFAltZ6n9b6LLAAmOp8gtY6W2u9FajZR30J8LXWukBrXQh8DbhmcWl7S9txH3ttS7u0wNgBKyjc2PbSZq37XOe1v5PHGK/Z+b/azz280XjsPBgSLjC6v0vy67n2XnMPQnO47G9wQyNG1nsZU2c7qWkL0SSdgUNO3+fYj7X0a+sXHg8lxwlQRhLz2tHjjlZ21xHG4LLC7LrPraw7d4fAEGPHrJ1Lak/0uRsBBR0HGkkbjMVRamOtMN7XzPVsh6BQaBPl7ihancmTtqw9LoSnUUrdppRar5Raf/z48YZfEB4PaILKCwAvHoh2yp60u401HuvrIs/PAr8AaJtofN/7cig5VnvX9+ENRl03OAI6pRkjzuvqIi88YOzA5Q0tbR9l6qRtlf20hWiKw0AXp+8T7Mdc+lqt9Wta6yFa6yFxcXENX9m+Klpw6THAB1ra3cYaj/UNRsvfC+2cNuzoOdHYdSuzRhe51kb3eOd04/ugMGM0dV1J2xtGjvs4UydtmactRJOsA3oqpZKVUkHATKCxRcEvgUlKqXb2AWiT7Meaz77ASmCp0Sr32pq2Y+R4TA+I6FT/tK+adeeQtsYGHjs/q9pHGowBaGdOQKdBVccSLoCcDbV3pXvDHG0fZ+psV1nTlu5xIRqktbYAd2Mk20xgodZ6h1LqKaXUFACl1AVKqRzgauBVpdQO+2sLgD9hJP51wFP2Y80XYawbHXjG21vaucac64AgiOtVd0vbscxodI0u7L7TjHr0riVVx3KdBqE5JFwAZ4tr/6UgPwtCooxNN4QpmTxpS/e4EE2htV6itU7RWnfXWj9tP/aY1nqx/et1WusErXWY1jpGa93X6bVvaq172P/MdVlQ9s0eAuxJ22L10pp28VGItM+NjuttrJ1dW/2++IixslnNuvOAa4x52189WjVn+/BG8A+qvpSnYzBabV3k+XullW1ypk7aUtMWwgsEBEObdvg7krbXtrSPVC1oEpcCFSXGOuQ1OU/3cuYfCJOeNurS6143jh3eaMxVduwr7XhdSJQkbS9l6qQtNW0hvER4fGXS9tru8VNHqrYidazidbyWLuz6Bov1nGisfPbdM8aiKkc2Q6f06ucoZa9r15j2dfaM8UuCjBw3NVNnO6lpC+ElwuPxL8kDvLSlba2AkuPGADRwStq11LXz90JASNW5zpQyWtvlxfDRLXD2dNXIcWcJF8CxTCgrqjpWuN94lKRtaiZP2tI9LoRXiOiAOm0kba9saZ8+BuiqlnZotDEora6kHd0d6upBjE+FwTfCvhXG986D0BwShhjv59zalpHjXsHUSbtqGVNJ2kKYWng8nM4DtHduzemYo+28SUdc79oXWMnPgphu9V9v3B+NXb2CIiCm57nPdxlq1LV/eLFqipgjaUc3cG3h0UydtGXDECG8REQHlPUsUaoEqzeuiOZI2pHOSbsXnNhVfd611dK4ZUbDYmHqP2H8o7W3yIMjYNwfYP93VVPE8vcZc+KDI5r1UYR7mTxp2/D3Uyiz71YjhK+zT/vq6HfS/DXtI1uMmrOzU3W0tMuK7D0MdkUHjU1Fas7Rrk3qVBh2e93PD7kZYnvBl38ES7m9BS9d42Zn8qStpZUthDewJ+14vyJz17T3LINXx8CqF6ofLz5irCUeGlt1LC7FeHSua+fvMx5dkVz9A2HyX4wBaGv+bU/aMgjN7EydtK1WTaAkbSHMzz5Aq6N/EWUV9WxZ6ckKD8DHtwAaDq6u/lzxUaNr2rkru3IEuVNdu6452uerxwRImQzfPmssdypJ2/RMnbSlpS2El7C3tLsEFnOytMLNwZyHijJYeIOx3nfKpcaiJ1anz1GcWzVy3CE83lhT3DlpF+w1BpiFNWKjlcaa9DRY7SuoSfe46Zk6aVttmgB/U38EIQQYg6MCQ+nsX0ThGRMm7S8eNhY6ufLfMOBqYxnSvO1VzzsvYeqglNHazlgE3/0VCvYbLe3obsZzrhLbo6r2HdvLddcVbtGojKeUmqyU2qWUylJKPVzL84lKqRVKqU1Kqa1KqcucnhuglFqtlNqhlNqmlApxVfCOgWhCCJNTCsLjifc7yckzZ90dTdNsWQAb5sKI+6D3zyBhqHH80Nqqc5yXMHU26Wlo3wdWPA0vpcG+71qmC3v8Y3DDYiOBC1NrMGkrpfyBl4FLgVRgllIqtcZpj2DsGDQIY7u/f9lfGwC8A/zKvvHAWMBlv0ZbrFrmaAvhLSI6EKsLKTRb0v7+OWOBk4sfNb5vm2AkaEfSPnvGGCVes3scoMsFcONncN92mPCEsbpZ78tdH2NAsLG1pzC9xrS0hwJZWut9WuuzwAJgao1zNBBp/7otkGv/ehKwVWu9BUBrna+1dtkoE6N7XJK2EF4hPJ4oWyEnS0zUPV5yAvL3QJ8rwD/AOFa59rc9aVcurFLLsqQOUV1g5P1wyzLoN61lYxam1pik3Rk45PR9jv2YsyeA6+z78C4B7rEfTwG0UupLpdRGpdTvansDpdRtSqn1Sqn1x48fb3TwFpuWzUKE8Bbh8URY8ikut1Bhlu05D60xHrtcWP14l2Fw8iAU5xn1bKi9pS1EE7kq480C5mmtE4DLgLeVUn5AADASmG1/vFIpNb7mi7XWr2mth2ith8TFNX7UpNS0hfAiEfEEW0sIoZwis4wgP/iTsZ91p0HVj3ex17Vz1ta+hKkQ56kxSfsw0MXp+wT7MWe/BBYCaK1XAyFALEar/Hut9Qmt9RmMVngtW9KcH6lpC+FFwo2WaHtlosFoh9ZAxzQIrDG+tuNAI5kfWlP7EqZCnKfGJO11QE+lVLJSKghjoNniGuccBMYDKKX6YCTt48CXQH+lVKh9UNoYIMNVwUtNWwgvEmHM1W5PoTmmfVWUQe4mSBx27nMBwUbiPrTO6B4PDDXmXwvRTA0mba21BbgbIwFnYowS36GUekopNcV+2m+BW5VSW4D5wI3aUAg8j5H4NwMbtdafuyp4Y3EVqWkL4RWcWtqFJSZoaR/ZbCxaUrOe7ZAw1EjqhdlGPVv2SBAuENCYk7TWSzC6tp2PPeb0dQYwoo7XvoMx7cvlLDabdI8L4S3sA7XiVJE5VkU7+JPx2KWWljYY07l+etmYe91xYOvFJbyaqZupFqssYyqE12gTjfYLoIMqMEdN+9AaYzeu8DoGzzoWWTlbLCPHhcuYOmlbbZpAqWkL4R38/CA2hX5+Bzy/pq210dJOrKNrHKBtZ4hMML6WpC1cxNRJW2raQngXlXghg/z2UFRS6u5Q6ndiD5QW1N017tDlAuMxsp6FVYRoAlNnPKtNpnwJ4VUSLyKcUkILd7s7kvodstez62tpQ1UXubS0hYuYOmlXWGVxFSG8ir3l2ql4s5sDacDBNdCmHcT0rP+8npOMUfEd01onLuH1GjV63FNJS1sILxOVSKF/DMlntjd8rjsd+sn4BaOh8lxsD3hgV/3nCNEEpm5py37aQngZpTgYNoA+FS5bg8n1Sk4Y+143VM8WogWYOuNZpKUthNc5FpVGB06gTx5q+GR3cGwS0lA9W4gWYO6kLTVtIbzOybjBAJzdv9rNkdRh74raNwkRohWYO2lLS1sIr2ON60uJDqYiu0bS3roQnkuB0kL3BAZQXgxb34fUqRDYxn1xCJ9l6qQtG4YI4X2iwtuw2dYD/5y1VQct5bDsSTidB7u+cF9wWxZA+SkYerv7YhA+zdRJ22hpm/ojCCFqiAoNYr1OIaQgw2jZAmx8C07lQEAbyPyfewLTGtb+x+gWTxjinhiEzzN1xpOathDep11oEBtsKShtg5x1xhaYK/8OicMh/XrY+w2cLWn9wPZ9Cyd2wdDbZMcu4TbmTtpS0xbC60SFBrLJ1hONMhYx2TAPio/AuD9AnyvAUgZZy1o/sLX/gdAY6Dut9d9bCDvzL64iNW0hvEpUaCDFhHIirCdx+76Fwv2QNAqSR4HVAm2iIfMzYzCYK1ktxi8Hpw5DyXGjZR8WYzxXeAB2L4WR90NgiGvfV4gmMG3S1lrLhiFCeKHgAH9Cg/zJDu1H3KGPjYNXzzMe/QOg12WQuRgsZyEgqPlvePo4fHQzZK8CbXMKJNJI0hfeAeteBxQMubn57ydEM5g2aVttGkC6x4XwQu1Cg9gVlMoFfAzdxkHX4VVP9rkCNr8D+7+HnhOa90bHd8O70+H0MRh+L0QnG9tpBraBH+fAN08aCbv8NPT+GbRNaN77CdFMpk3aFnvSloFoQnifqNBA1voN4rouw2Dik9Wf7DYWgsJh5/+al7SzV8GC2eAfCDd+DgmDqz+fNAL2r4SvHzW6zC+88/zfSwgXMW3SdrS0A6WmLYTXiQoN5FC5H9z51blPBoZAz4mw83P42fPg59/4C1vOGsuQ7vkKfnoForvB7IXQLqn285NHwS3LoThXWtnCI5g2aVe1tKWmLYS3iQoNIvfkqbpP6HMF7PgEDq2Frhc1fMGTB+GL3xvTts6eBr8ASJkMU/9pbLFZHz8/SdjCY5g2aUtNWwjv1S40kJNnztZ9Qo+Jxvrfmf9rOGnbrPDRrZC3HQZcA93HQ/JoCIl0bdBCtALTNlMtVmOUp9S0hfA+7UKDKCqtwGb/5fwcIZHQ/WLY/iFUlNZ/sTX/Nva/vuxvcPk/oM/lkrCFaZk3aUtLWwiv1bZNIDYNp8oq6j5p+D3GWuTrXq/7nBNZ8M1T0PMSGDjL9YEK0cpMm7Qru8f9TfsRhBB1aBdqzL8uPFNP0k4aaUwHW/WPqjXKndmssOhOCAiGK16UpUeFVzBtxpOWthDeq11YIACF9dW1AcY/CmfyjZHgNf30ijFS/NK/QmTHFohSiNZn3qQtNW0hvFaUvaVdVF9LG6DzYOh9ubEQypmCquMZi2H5nyDlUhgwowUjFaJ1mTdpS0tbCK9V1T3eQEsbYNwfje7xH140usS/eQoWXg/x/WDKHOkWF17F/FO+pKYthNeJauPoHm+gpQ0Qnwr9r4Y1r8LRrbB3OaTfAJc9Z9SzhfAips140tIWwntFtglEKeqfq+1s7MNgPWssO3r5P4wWtiRs4YVM29KWmrYQ3svfT9G2TWDjuscBYrrDrAUQHgedBrVscEK4kXmTtrS0hfBq7UKDONmY7nGHlEktF4wQHsK03eNS0xbCu0WFBjYtaQvhA0yb8WRrTiG8W1RTuseF8BGmTdpWm1HTlu5xIbxTk7vHhfABpk3aFVZpaQvhzaJCg6SlLUQNpk3aVTVtSdpCeKN2oYGcOWul3GJ1dyhCeAzTJu2q0eOm/QhCiHpEhTVyKVMhfIhpM57UtIXwbk1aFU0IH2HapC01bSG8W5PWHxfCR5g2aUtNWwjv5ties6BEkrYQDqZN2lLTFsK7JbQLBSCn8IybIxHCc5g241mtUtMWwpu1bRNIZEgABwskaQvhYNqkXbkimnSPC+G1EmNCOVhQ6u4whPAYpk/a0tIWwnslRoeSIy1tISqZNmlbpaYthNfrEh1KTmFp5f0uhK8zbcazWKWlLYS3S4wO5azVRt6pMneHIoRHMG3SttpsKAV+krSF8FqJ0cYIchmMJoTBtEm7wqallS2El+vSTpK2EM5Mm7StNi31bCG8XKeoNvgpZDCaEHamzXoWnuACZwAAIABJREFUq7S0hfB2QQF+dGzbRlraQtiZNmlbbTaZoy2ED0iMDpWkLYSdaZO21LSF8A1G0pYFVoSARiZtpdRkpdQupVSWUurhWp5PVEqtUEptUkptVUpdZj+epJQqVUpttv/5t6sCt1q17PAlhA9IjAnlxOlyzpy1uDsUIdwuoKETlFL+wMvARCAHWKeUWqy1znA67RFgodb6FaVUKrAESLI/t1drnebasI0V0WQgmhDeL6FdGwByCktJiY9wczRCuFdjst5QIEtrvU9rfRZYAEytcY4GIu1ftwVyXRdi7aw2m2zLKYQPqJyrnS91bSEak7Q7A4ecvs+xH3P2BHCdUioHo5V9j9NzyfZu8++UUqOaE6yzCpt0jwvhC2SBFSGquKp/eRYwT2udAFwGvK2U8gOOAIla60HAb4D3lFKRNV+slLpNKbVeKbX++PHjjXpDq0z5EsInRIcFERbkL0lbCBqXtA8DXZy+T7Afc/ZLYCGA1no1EALEaq3Ltdb59uMbgL1ASs030Fq/prUeorUeEhcX16jApaYthG9QStk3DpGkLURjst46oKdSKlkpFQTMBBbXOOcgMB5AKdUHI2kfV0rF2QeyoZTqBvQE9rkicKlpC+E7ZK62EIYGk7bW2gLcDXwJZGKMEt+hlHpKKTXFftpvgVuVUluA+cCNWmsNjAa2KqU2Ax8Cv9JaF7gicIvUtIXwGY6kbfy3IoTvanDKF4DWegnGADPnY485fZ0BjKjldR8BHzUzxlrJMqZC+I4u0aGUVdg4frqc9hEh7g5HCLcxbVFYNgwRwnc4RpAfki5y4eNMm/UsUtMWwmd0qUzaspyp8G2mTdpWqWkL4TMcq6LJYDTh60ybtCukpi1EkzViH4FgpdT79ufXKKWS7MdbbB+BxggJ9KdDZIgkbeHzGjUQzRNJTVuIpmnkPgK/BAq11j2UUjOBZ4EZ9udaZB+BxpJpX0KYuKVtkf20hWiqxuwjMBX4r/3rD4HxSimPuNESotvIQDTh80ybtK2yn7YQTdWYfQQqz7Gv0VAExNifa9Q+AuezLHFjJEaHcvRUGeUWq8uuKYTZmDZpV8h+2kK0pkbtIwDntyxxY/SKj0BryMg95bJrCmE2pk3a0tIWoskas49A5TlKqQCMrXbzG7uPQEu6IDkagDX7XbKoohCmZNqkbbFpAvxNG74Q7tCYfQQWA7+wfz0dWK611i25j0BjxYYH0z0ujLWStIUPM/HocZu0tIVoAq21RSnl2EfAH3jTsY8AsF5rvRh4A2Nr3SygACOxg7GPwFNKqQrAhgv3EWiKockxfLY1V9ZpED7LtEnbIjVtIZqsEfsIlAFX1/K6FttHoCmGJUczf+1Bdh49Rd9Obd0djhCtzrT9yxapaQvhc4ba69rSRS58lWmTtlVq2kL4nE5RbUho10aStvBZps16FqlpC+GThiXHsHZ/geytLXySKZO2zaaxaaSmLYQPGpYcTX7JWfYeP+3uUIRodaZM2hab8Ru2tLSF8D1DZb628GGmTNpWR9KWmrYQPqdrTCjtI4Klri18kimznsVmA6SlLYQvUkoxNDmaNfukri18jymTtqOlLTVtIXzTsORojp4qI6ew1N2hCNGqTJm0K6xS0xbClw1NNjYe+2lfvpsjEaJ1mTJpV7W0TRm+EKKZerYPJyo0UOrawueYMutV1rT9paUthC/y81MMTYpmVdYJbDapawvfYcqkbZUpX0L4vJ8N6MiRojKZ+iV8iimTtqOmLQPRhPBdk1I7EB4cwMcbc9wdihCtxpRJu6qlbcrwhRAu0CbIn8v6d2DJtiOUnrW6OxwhWoUps57UtIUQANPSEyg5a+WrjKPuDkWIVmHKpC01bSEEwNCkaDpHteGjjYfdHYoQrcKUSVtq2kIIMEaRT0vvzKo9x8k7VebucIRocaZM2lLTFkI4XDmoMzYNizZLa1t4P1NmPalpCyEcusWFMygxio82HJa1yIXXM2XSlpq2EMLZtPQEduUVk3HklLtDEaJFmTJpW2TDECGEk8v7dyTQX/HumoPuDkWIFmXOpG2VmrYQokq7sCCuHZrIgrUH2ZZT5O5whGgxpsx6VqlpCyFq+O0lvYgND+YPn2yrLKEJ4W1MmbQtUtMWQtQQGRLIY1eksu1wEW+tznZ3OEK0CFMmbavUtIUQtfhZ/46MSYnj71/t5miRzNsW3seUSbtCatpCiFoopfjT1H5UWG08+b8d7g5HCJczZdZz1LT9paYthKghMSaUe8f3ZOn2o/yQdcLd4QjhUqZM2o6adqB0jwshanHrqG5EhgTwsaxJLryMKZO21LSFEPUJCvBjQmo8yzLzqLDa3B2OEC5jyqQtNW0hREMm9+1AUWkFa/YVuDsUIVzGlFlPatpCiIaMTomjTaA/X+w44u5QhHAZUyZtmacthGhISKA/43rH8eWOPGyy2IrwEqZM2larJG0hRMMu6duB48XlbDxY6O5QhHAJUyZt2TBECNEYF/duT5C/H19sP+ruUIRwCZMmbRv+fgqlJGkLIeoWERLIyJ6xfLHjqOy1LbyCSZO2lq5xIUSjTO7bgZzCUnbkyl7bwvxMmbStVknaQojGmZAaj59CusiFVzBl0rbYtNSzhRCNEh0WxLDkGL7YIUlbmJ9Jk7aNAH9Thi6EcINL+3cg69hpNhyQhVaEuZky81mlpS2EaIKr0hNoHxHMnz7LlAFpwtQalbSVUpOVUruUUllKqYdreT5RKbVCKbVJKbVVKXVZLc+fVko94IqgLVYtm4UIIRotLDiABy7pxeZDJ1m8Jdfd4Qhx3hpM2kopf+Bl4FIgFZillEqtcdojwEKt9SBgJvCvGs8/DyxtfrgGq03LEqZCiCaZnp5A306R/PWLXZRVWN0djhDnpTEt7aFAltZ6n9b6LLAAmFrjHA1E2r9uC1T+KquU+jmwH3DZjvQVNi2bhQghmsTPT/HIz1I5fLKUN1btrzyutWbjwUJyCs+4MTohGqcxma8zcMjp+xz7MWdPANcppXKAJcA9AEqpcOAh4MlmR+rEal9cRQghmuKi7jFMSo3nXyuyOFZcxqo9J5jx6k9M+9eP3PDGWsot0gIXns1VzdVZwDytdQJwGfC2UsoPI5n/Q2t9ur4XK6VuU0qtV0qtP378eINvZpF52kKI8/T7y/pw1mrjkn98z3VvrOFQ4RluHJ7EvhMl1VrgQniigEaccxjo4vR9gv2Ys18CkwG01quVUiFALDAMmK6U+isQBdiUUmVa6386v1hr/RrwGsCQIUMaHNpptWkCpKYthDgPybFh3Dm2B4u35PLbSb24ekgCwQH+HCkqZc43WUxN60znqDbuDlOIWjWmpb0O6KmUSlZKBWEMNFtc45yDwHgApVQfIAQ4rrUepbVO0lonAS8Af6mZsM+HsbiK1LSFEOfn/okprHhgLNdd2JXgAH8AHr08FY3m6c8z3BydEHVrMPNprS3A3cCXQCbGKPEdSqmnlFJT7Kf9FrhVKbUFmA/cqFtwMqTFZpPucSGESyW0C+XucT1Ysu0o3+9uuEwnhDs0pnscrfUSjAFmzscec/o6AxjRwDWeOI/4aiU1bSFES7h1dDc+3JDDE4t3sPS+UZWtcCE8hSn7mKWmLYRoCcEB/jwxpS/7TpQw6R/f88Ky3RzIL3F3WEJUMmXSlpq2EKKljO3VnpevTadzVBte/GYPY/72Lde8uppDBTKPW7ifKTOf1LSFEC3pZwM68t6tF/LDQxfzu8m92HW0mGteXc3e4/XOXhWixZkzaUtNWwjRCjpFteHOsT1YcNuFVFhtzHh1NTuPnnJ3WMKHmTJpS01bCNGa+nSMZMFtF+Hvp5j52k9szTnp7pCEjzJt0paathCiNfVoH84Htw8nPDiA6f9ezf8tyeTkmbPuDkv4GFNmvgqpaQsh3CAxJpSP7xjO5QM68trKfYz+6wpe+Xav7BomWo0pk7bVqmXDECGEW7SPDOH5a9JYcu8ohiRF8+wXO5nx6upaE3dxWQXzftjPqbIKN0QqvJEpk7bFpgmUmrYQwo36dIzkzRsv4J/XDmJLThF/+HgbzgtBllVYueW/63nifxnc/tYG2UFMuESjVkTzNEZN2/uSdkVFBTk5OZSVlbk7FOFBQkJCSEhIIDAw0N2hiFpcPqATe4+V8I9lu0ntFMkto7phsdq4d/4m1mYXMGNIF95ff4gHP9jKCzPS8Kvn/67decV0impDeLAp/2sWrcCU/zIqrDYCvHAgWk5ODhERESQlJaGU9/1SIppOa01+fj45OTkkJye7OxxRh3su7kHGkSL+siSTXh0iWLw5l68y8nhySl9+MTyJxJhQ/vblLjpGhfD7S/vUeo1PNuXw24VbGNurPW/eeEErfwJhFqbMfN7a0i4rKyMmJkYStqiklCImJkZ6Xzycn5/i79ek0aN9ODfNXccHG3L49fie/GJ4EgB3ju3OdRcm8up3+3h95T5q7qf04YYcfrNwC9FhwSzfeYyVe2TDElE7UyZtixfP05aELWqSfxPmEB4cwH9uGEJMeBA3j0jmvgk9K59TSvHklH5MTI3nz59nctlLq/hoQw5nLTYWrjvEgx9uYUT3WL75zRi6RLfhz59lYrHa3PhphKcyZdK22mRFtJaQn59PWloaaWlpdOjQgc6dO1d+f/Zs4+aj3nTTTezatavec15++WXeffddV4QMQF5eHgEBAbz++usuu6YQ56NrTBirHx7PY1eknvPLlr+f4uVr03n2qv5YrDZ++8EWhj/zDb/7aCsje8Ty+i+G0DY0kN9f2oddecW8v/6Qmz6F8GSmq2lrrWXDkBYSExPD5s2bAXjiiScIDw/ngQceqHaO1hqtNX51/Pznzp3b4PvcddddzQ/WycKFC7nooouYP38+t9xyi0uv7cxisRAQYLpbRrSy+gaaBQX4MeOCRK4Z0oXv95xg7g/7CQ8O4LmrBxISaGwDemm/DgxNiub5r3ZzxcBORIZUDUAsq7CSe7KUwydLyT1Zik1D97hwerQPJzosqPI8q01TbrESGiT/Xr2N6f5GrTajFiQt7daTlZXFlClTGDRoEJs2beLrr7/mySefZOPGjZSWljJjxgwee8zYXn3kyJH885//pF+/fsTGxvKrX/2KpUuXEhoayqJFi2jfvj2PPPIIsbGx3HfffYwcOZKRI0eyfPlyioqKmDt3LsOHD6ekpIQbbriBzMxMUlNTyc7O5vXXXyctLe2c+ObPn8+cOXOYPn06R44coWPHjgB8/vnnPProo1itVuLj4/nqq68oLi7m7rvvZtOmTQA89dRTXH755cTGxnLypLE05YIFC1i2bBmvv/461113HREREWzYsIGxY8cybdo07r//fsrKyggNDWXevHn07NkTi8XCgw8+yNdff42fnx+/+tWv6NGjB6+99hoffvghAEuXLuXNN9/kgw8+aI2/NuHBlFKMSYljTEpcrc89cnkfpvzzB15ekcUdY7qzZNtRFm0+zNrsAmqUwytFhwUR5O9HcVkFJWeN6WWjU+K4f0JPBiW2a8mPI1qR6ZK2xZG0vbSm7fDk/3aQkevajQlSO0Xy+BV9z+u1O3fu5K233mLIkCEAPPPMM0RHR2OxWBg3bhzTp08nNTW12muKiooYM2YMzzzzDL/5zW948803efjhh8+5ttaatWvXsnjxYp566im++OIL5syZQ4cOHfjoo4/YsmUL6enptcaVnZ1NQUEBgwcP5uqrr2bhwoX8+te/5ujRo9xxxx2sXLmSrl27UlBQABg9CHFxcWzduhWtdWWirs+RI0f46aef8PPzo6ioiJUrVxIQEMAXX3zBI488wvvvv88rr7xCbm4uW7Zswd/fn4KCAqKiorj77rvJz88nJiaGuXPncvPNNzf1Ry980ICEKKald+aNlft5c9V+KqyabnFh3Dm2O91iw+ncrg2do9oAsPf4abKOnWbv8RIsVhsRIYFEhARgsdmYv/YQV/7rR8b2iuO+CSmkdYlqciyFJWdZlXWCoAA/IkICiAgOJDEmlLZtap+CmHXsNB3ahsi0tRZiup+qtLTdo3v37pUJG4zW7RtvvIHFYiE3N5eMjIxzknabNm249NJLARg8eDArV66s9drTpk2rPCc7OxuAVatW8dBDDwEwcOBA+vat/ZeNBQsWMGPGDABmzpzJnXfeya9//WtWr17NuHHj6Nq1KwDR0dEALFu2jE8//RQwWjTt2rXDYrHU+9mvvvrqynLAyZMnueGGG9i7d2+1c5YtW8Z9992Hv79/tfebPXs27733HrNnz2bDhg3Mnz+/3vcSwuGhyb05crKMfp0jmZrWmb6dImsdlNglOpSxvdrXeo07x/bgrdUHeO37vfz85R+4b0JP7r24Z71d+A7bDxfx1upsFm3OpdxSfVBcbHgQX90/plqXPBgJ+5IXvqdDZAgvzEzjgqToRn/ecouVotIKYsKCvXJ2kKuYLmk7WtreXtM+3xZxSwkLC6v8es+ePbz44ousXbuWqKgorrvuulqnJAUFVd3Q/v7+dSbH4ODgBs+py/z58zlx4gT//e9/AcjNzWXfvn1Nuoafn1/1laxqfBbnz/7HP/6RSy65hDvvvJOsrCwmT55c77VvvvlmrrrqKgBmzJhRmdSFaEh8ZAjzb7uwWdcICw7gjrHduf6irjy+aAcvLNvDjtxTPH/NQCJCAqmw2vhk02Fe/W4vuSfLCA8JIDw4AAXsO1FCm0B/rhqcwPTBCfaudwtHikp54IMt/HN5Fo9dUf0X9b99uZOQAD/8/RQzXl3N3eN6cO/4ngT41/7/9Zur9jPvx2wKSs5yuty496+7MJE//7x/sz736XILz325i5tGJNE1JqzhF5iI6TKfYxqEtLTd59SpU0RERBAZGcmRI0f48ssvXf4eI0aMYOHChQBs27aNjIyMc87JyMjAYrFw+PBhsrOzyc7O5sEHH2TBggUMHz6cFStWcODAAYDK7vGJEyfy8ssvA0a3fGFhIX5+frRr1449e/Zgs9n45JNP6oyrqKiIzp07AzBv3rzK4xMnTuTf//43Vqu12vt16dKF2NhYnnnmGW688cbm/VCEOE/GYLcBPH5FKst3HuPKf/3I6yv3MfZv3/K7D7cSEujP7GGJTOjTnn6d29ItLozHLk/lpz+M5y9X9ic9sR39Orflou4xTEtPYMYFXXj7p2wO5p+pfI+NBwv5ckcet43uzuf3juTKQQm8tDyLq19dXetuaEeLynhm6U6iQgOZPjiB305M4bL+HXh3zUE2Hiw85/z5aw8y9Oll/Of7fQ0uCfu3L3Yy78dsnlm6s/k/PA9juqRtrWxpS9J2l/T0dFJTU+nduzc33HADI0aMcPl73HPPPRw+fJjU1FSefPJJUlNTadu2bbVz5s+fz5VXXlnt2FVXXcX8+fOJj4/nlVdeYerUqQwcOJDZs2cD8Pjjj5OXl0e/fv1IS0ur7LJ/9tlnueSSSxg+fDgJCQl1xvXQQw/x4IMPkp6eXq11fvvtt9OhQwcGDBjAwIEDK3/hALj22mtJTk4mJSWl2T8XIc6XUoqbRiTzzi+HUVBylj9/nkn7yGDm3ngBn90zkkcuT+X/pg1gzqxBvP6LC7h5ZHKddev7JqQQ4OfHX780kqLWmmeW7iQ2PIhbRiUTERLI368ZyEuzBrHl0Eme/3r3Odd47ft9WLXm5WvTeWJKX+4Z35O/Th9IfEQIj3yyvdo89e2Hi3h80Q5sWvP0kkwmPv89S7YdOWeRGoB12QW89dMB2kcE88WOo2QdK3bRT9BDOKbweMqfwYMH6/ocLjyjuz70mV6w9kC955lRRkaGu0PwGBUVFbq0tFRrrfXu3bt1UlKSrqiocHNU5+f222/X8+bNa9Y1avu3AazXHnDP1venoftZuMfRolK9Pjtf22y2877G37/cqbs+9JnedLBQL8/M010f+kz/98f955z3yCfbdLfff653HT1Veex4cZnu9cgS/duFm885//OtubrrQ5/pN1ft01prXVR6Vo/+63J94V+W6fzT5frbXcf0pOe/010f+kzPem21PnaqrPK1pWctetxzK/Tw//tGH8wv0b0fWarvf39Tkz/bmXKLLimv0BZr/T+f8gqrnvPNbv3OT9lNfo+aGns/m66mbfWRmravO336NOPHj8disaC15tVXXzXlHOm0tDTatWvHSy+95O5QhKgUHxlCfGRIs65x25juvLvmIH9Zksmp0goSo0OZeUHiOefdPzGFRZsP86fPMnjr5qEopXhj1X7KLTbuHNv9nPMv7deB0Slx/P2r3VzWvyNP/S+DnMJS3r/tQqLDghiTEseI7jHMX3eIpz/P4Io5q3jlunQGJbZjzvI97Dtewls3D6VLdCjXDktk3o/Z3D8hhS7RobV+DqtN83VGHuuyC9hz7DR78oo5UlQ1riXAT9G2TSDXDkvklpHdaBtq9D7szivmvgWbyThizPIpKbdw2+hzP4+rme5/wQqpafuEqKgoNmzY4O4wms2xWI0Q3iY8OID7JvTk0UU7AHhxZhpBAec2pqLDgvj1hBT+9FkGy3ceY3DXdrz1YzaXD+hEt7jwc85XSvHUlL5MeuF7rnl1NQfyz/C7yb0Y4jQSPcDfj+sv7Ep6YhS3v72BGa/+xK2jk/n3d/uYPjiB0fb577eO6sbbqw/w6vd7zxncVlZh5eONh3nt+71k558hJNCPHu3DubBbDN3jwgj096PcYqPcYmVP3mnmLM9i3g/Z3DQiicg2gfz1y12EBwfwyux0Pt92hL8s2Ym/nx+/HNmyG/uYLmlLTVsIITzDzKGJvLX6AKFB/lwxoFOd591wUVfeXXPAWHe9fwdKzlq5a1zdrdKk2DDuGNOdF7/Zw5iUOH5VRwu2b6e2fHbPSO6Zv4mXV+wlNjyYR35WtYtah7YhXDU4gYXrc7j34p60jwzhdLmFd346wOsr93PidDkDE9ryyux0JvXtUG9eyTxyipe+2cNLy7MAuLh3e569agBxEcFMTI3HatP86bMMAvxU5UYxLcF0Sdsx5SvQyxdXEUIITxfo78end43A30/VO/c70N+PR3+Wyk3z1vHyir1MSo2nd4fIeq9957juxEYEc8WAjvVeOyo0iHk3DeWdnw7Qr3NbokKrzx2/Y0x33l93kBe/2UOHyBDe+GE/J89UMKpnLHeMTeOibo3bWbFPx0heuW4wmUdOcay4nNE9YytfF+Dvx0uzBnHXuxt5fPEO1uzPZ2JqPGNT2tOuxlz25jJd0paathBCeI6wRq58NrZXHKNT4vh+93HuvrhHg+cHB/hz/YVdG3Vt/3pat4kxoUwZ2Il31xwEYHzv9twzvud5rQ4HRvLu0/Hc44H+fvzz2nSe/WIni7fksmTbUfwUDEmK5pGf9WFAwvm9X02mS9rBAX6kdYkiKrT2qQhCCCE8j1KK564ewOaDJ12WwBrrwcm9aRcWxFXpCfTr3LbhF5ynoAA/Hr08lT9e1oeth4v4JjOPrzPyiAhxXb4yXXO1Z3wEn941oknL44nGGTdu3DkLpbzwwgvccccd9b4uPNwYTJKbm8v06dNrPWfs2LGsX7++3uu88MILnDlTtVjDZZdd1qi1wRsrLS2NmTNnuux6QoimaR8RwqS+HVr9fTtHteHxK/q2aMJ25uenSOsSxW8n9eKL+0aTHOu6VdlMl7RFy5k1axYLFiyodmzBggXMmjWrUa/v1KlT5Y5W56Nm0l6yZAlRUa75jTwzMxOr1crKlSspKSlxyTVr09RlWIUQoikkaYtK06dP5/PPP+fsWWPJwezsbHJzcxk1alTlvOn09HT69+/PokWLznl9dnY2/fr1A6C0tJSZM2fSp08frrzySkpLSyvPu+OOOxgyZAh9+/bl8ccfB+Cll14iNzeXcePGMW7cOACSkpI4ceIEAM8//zz9+vWjX79+vPDCC5Xv16dPH2699Vb69u3LpEmTqr2Ps/nz53P99dczadKkarFnZWUxYcIEBg4cSHp6euVGIM8++yz9+/dn4MCBlTuTOfcWnDhxgqSkJMBYznTKlClcfPHFjB8/vt6f1VtvvVW5atr1119PcXExycnJVFRUAMYSsc7fCyGEM9PVtH3G0ofh6DbXXrNDf7j0mTqfjo6OZujQoSxdupSpU6eyYMECrrnmGpRShISE8MknnxAZGcmJEye48MILmTJlSp2jLl955RVCQ0PJzMxk69at1bbWfPrpp4mOjsZqtTJ+/Hi2bt3Kvffey/PPP8+KFSuIjY2tdq0NGzYwd+5c1qxZg9aaYcOGMWbMmMr1wufPn89//vMfrrnmGj766COuu+66c+J5//33+frrr9m5cydz5szh2muvBYxduB5++GGuvPJKysrKsNlsLF26lEWLFrFmzRpCQ0Mr1xGvz8aNG9m6dWvldqW1/awyMjL485//zI8//khsbCwFBQVEREQwduxYPv/8c37+85+zYMECpk2bRmCgjNkQQpxLWtqiGucucueuca01f/jDHxgwYAATJkzg8OHD5OXl1Xmd77//vjJ5DhgwgAEDBlQ+t3DhQtLT0xk0aBA7duyodTMQZ6tWreLKK68kLCyM8PBwpk2bVrlmeHJyMmlpaUD1rT2drV+/ntjYWBITExk/fjybNm2ioKCA4uJiDh8+XLl+eUhICKGhoSxbtoybbrqJ0FBjBSXHNpv1mThxYuV5df2sli9fztVXX135S4nj/FtuuYW5c+cCMHfuXG666aYG308I4Zukpe2p6mkRt6SpU6dy//33s3HjRs6cOcPgwYMBePfddzl+/DgbNmwgMDCQpKSkWrfjbMj+/ft57rnnWLduHe3atePGG288r+s4OLb1BGNrz9q6x+fPn8/OnTsru7NPnTrFRx991ORBaQEBAdhsxop89W3f2dSf1YgRI8jOzubbb7/FarVWlhiEEKImaWmLasLDwxk3bhw333xztQFoRUVFtG/fnsD4MVKeAAAJ9ElEQVTAwGpbXtZl9OjRvPfeewBs376drVu3AkbCDAsLo23btuTl5bF06dLK10RERFBcfO6OPKNGjeLTTz/lzJkzlJSU8MknnzBq1KhGfR6bzcbChQvZtm1b5fadixYtYv78+URERJCQkMCnn34KQHl5OWfOnGHixInMnTu3clCco3s8KSmpcmnV+gbc1fWzuvjii/nggw/Iz8+vdl2AG264gWuvvbbFW9lKqclKqV1KqSyl1MO1PB+slHrf/vwapVSS03O/tx/fpZS6pEUDFULUSpK2OMesWbPYsmVLtaQ9e/Zs1q9fT//+/Xnrrbfo3bt3vde44447OH36NH369OGxxx6rbLEPHDiQQYMG0bt3b6699tpq23redtttTJ48uXIgmkN6ejo33ngjQ4cOZdiwYdxyyy0MGjSoUZ9l5cqVdO7cmU6dqpZYHD16NBkZGRw5coS3336bl156iQEDBjB8+HCOHj3K5MmTmTJlCkOGDCEtLY3nnnsOgAceeIBXXnmFQYMGVQ6Qq01dP6u+ffvyxz/+kTFjxjBw4EB+85vfVHtNYWFho0fqnw+llD/wMnApkArMUkql1jjtl0Ch1roH8A/gWftrU4GZQF9gMvAv+/WEEK1I6Vr2I3WnIUOG6Ibm83qrzMxM+vTp0/CJwut8+OGHLFq0iLfffrvW52v7t6GU2qC1HtLY91BKXQQ8obW+xP797wG01v/ndM6X9nNWK6UCgKNAHPCw87nO59X3nr58PwvRFI29n6WmLYSb3XPPPSxdupQlS5a09Ft1Bg45fZ8DDKvrHK21RSlVBMTYj/9U47WdWy5UIURtJGkL4WZz5sxxdwgupZS6DbgNIDHx3P2VhRDnT2raQviOw0AXp+8T7MdqPcfePd4WyG/kawHQWr+mtR6itR4SFxfnotCFECBJ2+N42hgD4X4u/DexDuiplEpWSgVhDCxbXOOcxcAv7F9PB5ZrI4DFwEz76PJkoCew1lWBCSEaR7rHPUhISAj5+fnExDRuf1fh/bTW5OfnExIS4oprWZRSdwNfAv7Am1rrHUqpp4D1WuvFwBvA20qpLKAAI7FjP28hkAFYgLu01tZmByWEaBJJ2h4kISGBnJwcjh8/7u5QhAcJCQkhISHBJdfSWi8BltQ49pjT12XA1XW89mngaZcEIoQ4L5K0PUhgYCDJycnuDkMIIYSHkpq2EEIIYRKStIUQQgiTkKQthBBCmITHLWOqlDoO1L8bhSEWqHsBaPfwxJjAM+PyxJjAXHF11Vp79EToRt7PZvqZu5snxgQSV1PUFVOj7mePS9qNpZRa35R1l1uDJ8YEnhmXJ8YEEpc7eOpn88S4PDEmkLiaorkxSfe4EEIIYRKStIUQQgiTMHPSfs3dAdTCE2MCz4zLE2MCicsdPPWzeWJcnhgTSFxN0ayYTFvTFkIIIXyNmVvaQgghhE8xXdJWSk1WSu1SSmUppR52YxxvKqWOKaW2Ox2LVkp9rZTaY39s18oxdVFKrVBKZSildiilfu0hcYUopdYqpbbY43rSfjxZKbXG/nf5vn3nqVallPJXSm1SSn3mQTFlK6W2KaU2K6XW24+59e+wpXjC/eyJ97I9Bo+7nz35XrbH4fX3s6mStlLKH3gZuBRIBWYppVLdFM48YHKNYw8D32itewLf2L9vTRbgt1rrVOBC4C77z8fdcZUDF2utBwJpwGSl1IXAs8A/tNY9gELgl60cF8CvgUyn7z0hJoBxWus0p6kh7v47dDkPup/n4Xn3Mnjm/ezJ9zL4wv2stTbNH+Ai4Eun738P/N6N8SQB252+3wV0tH/dEdjl5p/XImCiJ8UFhAIbgWEYCwwE1PZ320qxJNhvmIuBzwDl7pjs75sNxNY45jF/hy78nB5zP3v6vWyPw6PuZ0+6l+3v6xP3s6la2kBn4JDT9zn2Y54iXmt9xP71USDeXYEopZKAQcAaPCAue7fVZuAY8DWwFziptbbYT3HH3+ULwO8Am/37GA+ICUADXymlNiilbrMfc/vfYQvw5PvZo37ennQ/e+i9DD5yP8vWnC1Ea62VUm4Zmq+UCgc+Au7TWp9SSrk9Lq21FUhTSkUBnwC9WzsGZ0qpy4FjWusNSqmx7oylFiO11oeVUu2Br5VSO52fdOe/LV/k7p+3p93PnnYvg2/dz2ZraR8Gujh9n2A/5inylFIdAeyPx1o7AKVUIMYN/q7W+mNPictBa30SWIHRVRWllHL84tjaf5cjgClKqWxgAUaX2otujgkArfVh++MxjP8Uh+JBf4cu5Mn3s0f8vD35fvagexl86H42W9JeB/S0jwgMAmYCi90ck7PFwC/sX/8CowbVapTxK/gbQKbW+nkPiivO/ls5Sqk2GHW5TIwbfro74tJa/15rnaC1TsL4d7Rcaz3bnTEBKKXClFIRjq+BScB23Px32EI8+X52+8/bE+9nT7yXwcfu59YuyrugqH8ZsBujjvJHN8YxHzgCVGDUSn6JUUP5BtgDLAOiWzmmkRj1k63AZvufyzwgrgHAJntc24HH7Me7AWuBLOADINhNf5djgc88ISb7+2+x/9nh+Dfu7r/DFvy8br+fPfFetsflcfezp9/L9li8+n6WFdGEEEIIkzBb97gQQgjhsyRpCyGEECYhSVsIIYQwCUnaQgghhElI0hZCCCFMQpK2OIdS6lul1JCGzxRCeDK5l72PJG0hhBDCJCRp+wil1HX2fXA3K6VetS/6f1op9Q/7vrjfKKXinF5ytf383UqpUfZrhCil5tr3ht2klBpnP+6vlHpOKbVdKbVVKXWP/fgzytgLeKtS6jk3fGwhvI7cy75NkrYPUEr1AWYAI7TWaYAVmA2EAeu11n2B74DHnV4WoLUeCtzndPwujPXt+wOzgP8qpUKA2zC2NkzTWg8A3lVKxQBXAn3tx/7cwh9TCK8n97KQXb58w3hgMLDOvkNQG4wF6m3A+/Zz3gE+dnqN4+sNGDcxGMsqzgHQWu9USh0AUoAJwL+1fQs8rXWBfZH+MuANpdRnGPvbCiGaR+5lHyctbd+ggP9qrdPsf3pprZ+o5TznNW3L7Y9WzuOXO/tNPxT4ELgc+KKp1xBCnEPuZR8nSds3fANMt+/nilIqWinVFePv37EDzrXAqgausxKjKw6lVAqQCOwCvgZud2yBZ79+ONBWa70EuB8Y6NqPJIRPknvZx0n3uA/QWmcopR4BvlJK+WHsZnQXUAIMtT93DKNWVp9/Aa8opbYBFuBGrXW5Uup1jK61rUqpCuA/GHsAL7LXyRTwm5b4bEL4ErmXhezy5cOUUqe11uHujkMI0TxyL/sO6R4XQgghTEJa2kIIIYRJSEtbCCGEMAlJ2kIIIYRJSNIWQgghTEKSthBCCGESkrSFEEIIk5CkLYQQQpjE/wN9gnWDQGBEWwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plotAccuracyAndLoss(history3, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Takeaway: for this type of problem the accuracy decreases when we drop the first element of the one hot encoded target array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experiment 4: Can we treat the problem as a regression and have only 1 neuron in output layer that will output the number in the image?\n",
    "more info: https://stats.stackexchange.com/questions/299826/why-is-handwriting-recognition-treated-as-classification-problem-instead-of-a-re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0828 05:43:58.406590 140595318212416 callbacks.py:862] `period` argument is deprecated. Please use `save_freq` to specify the frequency in number of samples seen.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 56000 samples, validate on 14000 samples\n",
      "Epoch 1/50\n",
      "56000/56000 - 3s - loss: 1.8195 - accuracy: 0.1738 - val_loss: 1.0272 - val_accuracy: 0.1949\n",
      "Epoch 2/50\n",
      "56000/56000 - 3s - loss: 0.9447 - accuracy: 0.1949 - val_loss: 0.9348 - val_accuracy: 0.1992\n",
      "Epoch 3/50\n",
      "56000/56000 - 3s - loss: 0.7412 - accuracy: 0.1974 - val_loss: 0.6436 - val_accuracy: 0.2010\n",
      "Epoch 4/50\n",
      "56000/56000 - 3s - loss: 0.6319 - accuracy: 0.1996 - val_loss: 0.5835 - val_accuracy: 0.2039\n",
      "Epoch 5/50\n",
      "56000/56000 - 3s - loss: 0.5404 - accuracy: 0.2009 - val_loss: 0.5687 - val_accuracy: 0.2008\n",
      "Epoch 6/50\n",
      "56000/56000 - 3s - loss: 0.4849 - accuracy: 0.2009 - val_loss: 0.5435 - val_accuracy: 0.2013\n",
      "Epoch 7/50\n",
      "56000/56000 - 3s - loss: 0.4354 - accuracy: 0.2009 - val_loss: 0.5464 - val_accuracy: 0.2044\n",
      "Epoch 8/50\n",
      "56000/56000 - 3s - loss: 0.3838 - accuracy: 0.2019 - val_loss: 0.4633 - val_accuracy: 0.2039\n",
      "Epoch 9/50\n",
      "56000/56000 - 3s - loss: 0.3534 - accuracy: 0.2020 - val_loss: 0.4766 - val_accuracy: 0.2020\n",
      "Epoch 10/50\n",
      "\n",
      "Epoch 00010: val_loss improved from inf to 0.46762, saving model to mnistclassif_exp4.h5\n",
      "56000/56000 - 3s - loss: 0.3259 - accuracy: 0.2023 - val_loss: 0.4676 - val_accuracy: 0.2040\n",
      "Epoch 11/50\n",
      "56000/56000 - 3s - loss: 0.3065 - accuracy: 0.2033 - val_loss: 0.4533 - val_accuracy: 0.2024\n",
      "Epoch 12/50\n",
      "56000/56000 - 3s - loss: 0.2818 - accuracy: 0.2034 - val_loss: 0.4282 - val_accuracy: 0.2010\n",
      "Epoch 13/50\n",
      "56000/56000 - 3s - loss: 0.2671 - accuracy: 0.2033 - val_loss: 0.4508 - val_accuracy: 0.2029\n",
      "Epoch 14/50\n",
      "56000/56000 - 3s - loss: 0.2516 - accuracy: 0.2028 - val_loss: 0.4588 - val_accuracy: 0.1948\n",
      "Epoch 15/50\n",
      "56000/56000 - 3s - loss: 0.2286 - accuracy: 0.2040 - val_loss: 0.4119 - val_accuracy: 0.2004\n",
      "Epoch 16/50\n",
      "56000/56000 - 3s - loss: 0.2214 - accuracy: 0.2034 - val_loss: 0.4067 - val_accuracy: 0.2027\n",
      "Epoch 17/50\n",
      "56000/56000 - 3s - loss: 0.2162 - accuracy: 0.2034 - val_loss: 0.4022 - val_accuracy: 0.2032\n",
      "Epoch 18/50\n",
      "56000/56000 - 3s - loss: 0.2056 - accuracy: 0.2033 - val_loss: 0.3929 - val_accuracy: 0.2039\n",
      "Epoch 19/50\n",
      "56000/56000 - 3s - loss: 0.1990 - accuracy: 0.2040 - val_loss: 0.4008 - val_accuracy: 0.2032\n",
      "Epoch 20/50\n",
      "\n",
      "Epoch 00020: val_loss improved from 0.46762 to 0.37853, saving model to mnistclassif_exp4.h5\n",
      "56000/56000 - 3s - loss: 0.1860 - accuracy: 0.2043 - val_loss: 0.3785 - val_accuracy: 0.2032\n",
      "Epoch 21/50\n",
      "56000/56000 - 3s - loss: 0.1818 - accuracy: 0.2041 - val_loss: 0.4107 - val_accuracy: 0.2040\n",
      "Epoch 22/50\n",
      "56000/56000 - 3s - loss: 0.1749 - accuracy: 0.2038 - val_loss: 0.3821 - val_accuracy: 0.2039\n",
      "Epoch 23/50\n",
      "56000/56000 - 3s - loss: 0.1674 - accuracy: 0.2045 - val_loss: 0.3898 - val_accuracy: 0.2034\n",
      "Epoch 24/50\n",
      "56000/56000 - 3s - loss: 0.1609 - accuracy: 0.2045 - val_loss: 0.3753 - val_accuracy: 0.2029\n",
      "Epoch 25/50\n",
      "56000/56000 - 3s - loss: 0.1535 - accuracy: 0.2050 - val_loss: 0.3664 - val_accuracy: 0.2019\n",
      "Epoch 26/50\n",
      "56000/56000 - 3s - loss: 0.1621 - accuracy: 0.2045 - val_loss: 0.3551 - val_accuracy: 0.2035\n",
      "Epoch 27/50\n",
      "56000/56000 - 3s - loss: 0.1539 - accuracy: 0.2046 - val_loss: 0.3683 - val_accuracy: 0.2034\n",
      "Epoch 28/50\n",
      "56000/56000 - 3s - loss: 0.1495 - accuracy: 0.2038 - val_loss: 0.3411 - val_accuracy: 0.2030\n",
      "Epoch 29/50\n",
      "56000/56000 - 3s - loss: 0.1440 - accuracy: 0.2046 - val_loss: 0.3627 - val_accuracy: 0.2028\n",
      "Epoch 30/50\n",
      "\n",
      "Epoch 00030: val_loss did not improve from 0.37853\n",
      "56000/56000 - 3s - loss: 0.1440 - accuracy: 0.2046 - val_loss: 0.3786 - val_accuracy: 0.2022\n",
      "Epoch 31/50\n",
      "56000/56000 - 3s - loss: 0.1323 - accuracy: 0.2047 - val_loss: 0.3516 - val_accuracy: 0.2024\n",
      "Epoch 32/50\n",
      "56000/56000 - 3s - loss: 0.1344 - accuracy: 0.2053 - val_loss: 0.3589 - val_accuracy: 0.2015\n",
      "Epoch 33/50\n",
      "56000/56000 - 3s - loss: 0.1314 - accuracy: 0.2054 - val_loss: 0.3724 - val_accuracy: 0.2039\n",
      "Epoch 34/50\n",
      "56000/56000 - 3s - loss: 0.1268 - accuracy: 0.2048 - val_loss: 0.3636 - val_accuracy: 0.2046\n",
      "Epoch 35/50\n",
      "56000/56000 - 3s - loss: 0.1239 - accuracy: 0.2059 - val_loss: 0.3825 - val_accuracy: 0.2011\n",
      "Epoch 36/50\n",
      "56000/56000 - 3s - loss: 0.1234 - accuracy: 0.2057 - val_loss: 0.3659 - val_accuracy: 0.2019\n",
      "Epoch 37/50\n",
      "56000/56000 - 3s - loss: 0.1200 - accuracy: 0.2051 - val_loss: 0.3532 - val_accuracy: 0.2047\n",
      "Epoch 38/50\n",
      "56000/56000 - 3s - loss: 0.1202 - accuracy: 0.2056 - val_loss: 0.3602 - val_accuracy: 0.2034\n",
      "Epoch 39/50\n",
      "56000/56000 - 3s - loss: 0.1210 - accuracy: 0.2057 - val_loss: 0.3681 - val_accuracy: 0.2038\n",
      "Epoch 40/50\n",
      "\n",
      "Epoch 00040: val_loss improved from 0.37853 to 0.35121, saving model to mnistclassif_exp4.h5\n",
      "56000/56000 - 3s - loss: 0.1135 - accuracy: 0.2055 - val_loss: 0.3512 - val_accuracy: 0.2049\n",
      "Epoch 41/50\n",
      "56000/56000 - 3s - loss: 0.1124 - accuracy: 0.2057 - val_loss: 0.3674 - val_accuracy: 0.2044\n",
      "Epoch 42/50\n",
      "56000/56000 - 3s - loss: 0.1140 - accuracy: 0.2056 - val_loss: 0.3512 - val_accuracy: 0.2038\n",
      "Epoch 43/50\n",
      "56000/56000 - 3s - loss: 0.1079 - accuracy: 0.2061 - val_loss: 0.3534 - val_accuracy: 0.2049\n",
      "Epoch 44/50\n",
      "56000/56000 - 3s - loss: 0.1066 - accuracy: 0.2058 - val_loss: 0.3621 - val_accuracy: 0.2028\n",
      "Epoch 45/50\n",
      "56000/56000 - 3s - loss: 0.1106 - accuracy: 0.2057 - val_loss: 0.3765 - val_accuracy: 0.2034\n",
      "Epoch 46/50\n",
      "56000/56000 - 3s - loss: 0.1067 - accuracy: 0.2057 - val_loss: 0.3596 - val_accuracy: 0.2042\n",
      "Epoch 47/50\n",
      "56000/56000 - 3s - loss: 0.1038 - accuracy: 0.2061 - val_loss: 0.3446 - val_accuracy: 0.2043\n",
      "Epoch 48/50\n",
      "56000/56000 - 3s - loss: 0.1026 - accuracy: 0.2063 - val_loss: 0.3452 - val_accuracy: 0.2039\n",
      "Epoch 49/50\n",
      "56000/56000 - 3s - loss: 0.1038 - accuracy: 0.2063 - val_loss: 0.3381 - val_accuracy: 0.2046\n",
      "Epoch 50/50\n",
      "\n",
      "Epoch 00050: val_loss improved from 0.35121 to 0.34943, saving model to mnistclassif_exp4.h5\n",
      "56000/56000 - 3s - loss: 0.1050 - accuracy: 0.2059 - val_loss: 0.3494 - val_accuracy: 0.2034\n"
     ]
    }
   ],
   "source": [
    "FILENAME = 'mnistclassif_exp4.h5';\n",
    "checkpointer = ModelCheckpoint(filepath=FILENAME, verbose=1,period=10, save_best_only=True)\n",
    "model4 = Sequential([\n",
    "    Dense(300, activation='relu', input_shape=(n,)\n",
    "         ),\n",
    "    Dropout(0.1),\n",
    "    Dense(100, activation='relu', input_shape=(n,)\n",
    "         ),\n",
    "    Dropout(0.1),\n",
    "    Dense(1)\n",
    "])\n",
    "model4.compile(optimizer='adam',\n",
    "              loss='mean_squared_error',\n",
    "              metrics=['accuracy'])\n",
    "history4 = model4.fit(\n",
    "    X_train_scaled,\n",
    "    y_train,\n",
    "    epochs=50,\n",
    "    verbose=2,\n",
    "    batch_size=50,\n",
    "    validation_data=(X_test_scaled, y_test),\n",
    "    callbacks=[checkpointer, tensorboard_callback]\n",
    ")\n",
    "model.save(FILENAME)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### As the answer in the stackexchange link stated we can't treat this problem as a regression and the test seems to confirm it. I'm still curious about wether it's possible to make it work, if you have some ideas please let me know!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "TPU",
  "colab": {
   "name": "digit_classification.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "conda_tensorflow_p36",
   "language": "python",
   "name": "conda_tensorflow_p36"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}