4_keras_adv_feat_eng-lab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advanced Feature Engineering in Keras \n",
    "\n",
    "## Learning Objectives\n",
    "\n",
    "1. Process temporal feature columns in Keras.\n",
    "2. Use Lambda layers to perform feature engineering on geolocation features.\n",
    "3. Create bucketized and crossed feature columns.\n",
    " \n",
    "\n",
    "## Introduction \n",
    "\n",
    "In this notebook, we use Keras to build a taxifare price prediction model and utilize feature engineering to improve the fare amount prediction for NYC taxi cab rides. \n",
    "\n",
    "Each learning objective will correspond to a __#TODO__ in this student lab notebook -- try to complete this notebook first and then review the [Solution Notebook](../solutions/4_keras_adv_feat_eng.ipynb) for reference. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up environment variables and load necessary libraries \n",
    "We will start by importing the necessary libraries for this lab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!sudo chown -R jupyter:jupyter /home/jupyter/training-data-analyst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.6.5\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "import logging\n",
    "import os\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow import feature_column as fc\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import models\n",
    "\n",
    "# set TF error log verbosity\n",
    "logging.getLogger(\"tensorflow\").setLevel(logging.ERROR)\n",
    "\n",
    "print(tf.version.VERSION)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load taxifare dataset\n",
    "\n",
    "The Taxi Fare dataset for this lab is 106,545 rows and has been pre-processed and split for use in this lab.  Note that the dataset is the same as used in the Big Query feature engineering labs.  The fare_amount is the target, the continuous value we’ll train a model to predict.  \n",
    "\n",
    "First, let's download the  .csv data by copying the data from a cloud storage bucket."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.isdir(\"../data\"):\n",
    "    os.makedirs(\"../data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Copying gs://cloud-training/mlongcp/v3.0_MLonGC/toy_data/taxi-train1_toy.csv...\n",
      "/ [1 files][  1.7 MiB/  1.7 MiB]                                                \n",
      "Operation completed over 1 objects/1.7 MiB.                                      \n",
      "Copying gs://cloud-training/mlongcp/v3.0_MLonGC/toy_data/taxi-valid1_toy.csv...\n",
      "/ [1 files][436.2 KiB/436.2 KiB]                                                \n",
      "Operation completed over 1 objects/436.2 KiB.                                    \n"
     ]
    }
   ],
   "source": [
    "# The `gsutil cp` command allows you to copy data between the bucket and current directory.\n",
    "!gsutil cp gs://cloud-training/mlongcp/v3.0_MLonGC/toy_data/taxi-train1_toy.csv ../data\n",
    "!gsutil cp gs://cloud-training/mlongcp/v3.0_MLonGC/toy_data/taxi-valid1_toy.csv ../data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check that the files were copied correctly and look like we expect them to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r-- 1 jupyter jupyter 1756557 Jun 14 04:50 ../data/taxi-train1_toy.csv\n",
      "-rw-r--r-- 1 jupyter jupyter  446676 Jun 14 04:50 ../data/taxi-valid1_toy.csv\n"
     ]
    }
   ],
   "source": [
    "!ls -l ../data/*.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==> ../data/taxi-train1_toy.csv <==\n",
      "fare_amount,passenger_count,pickup_longitude,pickup_latitude,dropoff_longitude,dropoff_latitude,hourofday,dayofweek\n",
      "8.1,1,-73.973731,40.791909999999994,-73.962737,40.767317999999996,14,4\n",
      "4.5,2,-73.98649499999999,40.739278000000006,-73.986083,40.730933,10,6\n",
      "2.9,1,-73.95604300000001,40.772026000000004,-73.956245,40.773934000000004,22,3\n",
      "7.0,1,-74.006557,40.705797,-73.980017,40.713617,6,3\n",
      "6.5,1,-73.98644300000001,40.741611999999996,-73.990215,40.746466999999996,10,2\n",
      "15.0,1,-73.96014404,40.7789917,-73.98536682,40.73873138,17,6\n",
      "5.5,1,-73.981625,40.74957,-73.97639000000001,40.754807,18,0\n",
      "9.0,3,-73.99884,40.734719,-73.978865,40.72422,21,1\n",
      "14.0,2,-73.986827,40.742839000000004,-73.94695899999999,40.780063,19,1\n",
      "\n",
      "==> ../data/taxi-valid1_toy.csv <==\n",
      "fare_amount,passenger_count,pickup_longitude,pickup_latitude,dropoff_longitude,dropoff_latitude,hourofday,dayofweek\n",
      "15.5,3,-73.98902199999999,40.718837,-73.974645,40.761427000000005,18,3\n",
      "7.5,1,-73.97336578,40.76422882,-73.98596954,40.75464249,20,0\n",
      "3.3,2,-73.961372,40.760443,-73.956565,40.767154999999995,2,6\n",
      "13.5,6,-73.989437,40.757082000000004,-73.98344200000001,40.725312,18,4\n",
      "7.5,2,-73.981992,40.740312,-73.965375,40.752895,13,4\n",
      "7.3,1,-73.99553,40.759465000000006,-73.978126,40.752683000000005,20,2\n",
      "13.5,5,-73.99021149,40.75678253,-73.95141602,40.7700119,7,3\n",
      "6.1,1,-74.005032,40.72971,-73.985805,40.722916999999995,19,4\n",
      "10.0,6,-73.95796800000001,40.765155,-73.960672,40.781222,12,1\n"
     ]
    }
   ],
   "source": [
    "!head ../data/*.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create an input pipeline \n",
    "\n",
    "Typically, you will use a two step process to build the pipeline. Step one is to define the columns of data; i.e., which column we're predicting for, and the default values.  Step 2 is to define two functions - a function to define the features and label you want to use and a function to load the training data.  Also, note that pickup_datetime is a string and we will need to handle this in our feature engineered model.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "CSV_COLUMNS = [\n",
    "    'fare_amount',\n",
    "    'pickup_datetime',\n",
    "    'pickup_longitude',\n",
    "    'pickup_latitude',\n",
    "    'dropoff_longitude',\n",
    "    'dropoff_latitude',\n",
    "    'passenger_count',\n",
    "    'key',\n",
    "]\n",
    "LABEL_COLUMN = 'fare_amount'\n",
    "STRING_COLS = ['pickup_datetime']\n",
    "NUMERIC_COLS = ['pickup_longitude', 'pickup_latitude',\n",
    "                'dropoff_longitude', 'dropoff_latitude',\n",
    "                'passenger_count']\n",
    "DEFAULTS = [[0.0], ['na'], [0.0], [0.0], [0.0], [0.0], [0.0], ['na']]\n",
    "DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A function to define features and labesl\n",
    "def features_and_labels(row_data):\n",
    "    for unwanted_col in ['key']:\n",
    "        row_data.pop(unwanted_col)\n",
    "    label = row_data.pop(LABEL_COLUMN)\n",
    "    return row_data, label\n",
    "\n",
    "\n",
    "# A utility method to create a tf.data dataset from a Pandas Dataframe\n",
    "def load_dataset(pattern, batch_size=1, mode='eval'):\n",
    "    dataset = tf.data.experimental.make_csv_dataset(pattern,\n",
    "                                                    batch_size,\n",
    "                                                    CSV_COLUMNS,\n",
    "                                                    DEFAULTS)\n",
    "    dataset = dataset.map(features_and_labels)  # features, label\n",
    "    if mode == 'train':\n",
    "        dataset = dataset.shuffle(1000).repeat()\n",
    "        # take advantage of multi-threading; 1=AUTOTUNE\n",
    "        dataset = dataset.prefetch(1)\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "****\n",
      "(OrderedDict([('pickup_datetime', <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'1', b'1'], dtype=object)>), ('pickup_longitude', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([-73.990524, -74.01029 ], dtype=float32)>), ('pickup_latitude', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([40.74851, 40.71395], dtype=float32)>), ('dropoff_longitude', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([-73.97306, -73.98807], dtype=float32)>), ('dropoff_latitude', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([40.744312, 40.714226], dtype=float32)>), ('passenger_count', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([19., 11.], dtype=float32)>)]), <tf.Tensor: shape=(2,), dtype=float32, numpy=array([10. ,  6.1], dtype=float32)>) \n",
      "***\n",
      "(OrderedDict([('pickup_datetime', <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'1', b'1'], dtype=object)>), ('pickup_longitude', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([-73.9507, -73.9171], dtype=float32)>), ('pickup_latitude', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([40.783253, 40.769863], dtype=float32)>), ('dropoff_longitude', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([-73.96801, -73.90942], dtype=float32)>), ('dropoff_latitude', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([40.792313, 40.768612], dtype=float32)>), ('passenger_count', <tf.Tensor: shape=(2,), dtype=float32, numpy=array([22., 22.], dtype=float32)>)]), <tf.Tensor: shape=(2,), dtype=float32, numpy=array([7.5, 4. ], dtype=float32)>) \n",
      "***\n"
     ]
    }
   ],
   "source": [
    "trainds=load_dataset('../data/taxi-train*',\n",
    "                       2,\n",
    "                       'train')\n",
    "\n",
    "print(\"****\")\n",
    "for elem in trainds.take(2):\n",
    "  print (elem, \"\\n***\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a Baseline DNN Model in Keras\n",
    "\n",
    "Now let's build the Deep Neural Network (DNN) model in Keras using the functional API. Unlike the sequential API, we will need to specify the input and hidden layers.  Note that we are creating a linear regression baseline model with no feature engineering. Recall that a baseline model is a solution to a problem without applying any machine learning techniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'pickup_longitude': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'pickup_longitude')>, 'pickup_latitude': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'pickup_latitude')>, 'dropoff_longitude': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'dropoff_longitude')>, 'dropoff_latitude': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'dropoff_latitude')>, 'passenger_count': <KerasTensor: shape=(None,) dtype=float32 (created by layer 'passenger_count')>}\n",
      "****\n",
      "{'pickup_longitude': NumericColumn(key='pickup_longitude', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), 'pickup_latitude': NumericColumn(key='pickup_latitude', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), 'dropoff_longitude': NumericColumn(key='dropoff_longitude', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), 'dropoff_latitude': NumericColumn(key='dropoff_latitude', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), 'passenger_count': NumericColumn(key='passenger_count', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None)}\n",
      "**++++\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict_values([NumericColumn(key='pickup_longitude', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='pickup_latitude', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='dropoff_longitude', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='dropoff_latitude', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None), NumericColumn(key='passenger_count', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=None)])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs = {\n",
    "        colname: layers.Input(name=colname, shape=(), dtype='float32')\n",
    "        for colname in NUMERIC_COLS\n",
    "    }\n",
    "print(inputs)\n",
    "print(\"****\")\n",
    "feature_columns = {\n",
    "        colname: fc.numeric_column(colname)\n",
    "        for colname in NUMERIC_COLS\n",
    "    }\n",
    "\n",
    "print(feature_columns)\n",
    "print(\"**++++\")\n",
    "feature_columns.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[ 0.   0.   1.   5. ]\n",
      " [ 0.   0.   1.   6.4]\n",
      " [ 0.   0.   1.  10.5]\n",
      " [ 0.   0.   1.  13.6]\n",
      " [ 0.   0.   1.  15.7]\n",
      " [ 0.   0.   1.  19.9]\n",
      " [ 0.   0.   1.  20.3]\n",
      " [ 0.   0.   1.   0. ]], shape=(8, 4), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "def mytest_numeric():\n",
    "    data = {'a': [15, 9, 17, 19, 21, 18, 25, 30],\n",
    "   'b': [5.0, 6.4, 10.5, 13.6, 15.7, 19.9, 20.3 , 0.0]}\n",
    "\n",
    "    a = tf.feature_column.numeric_column('a')\n",
    "    b = tf.feature_column.numeric_column('b')\n",
    "    a_buckets = tf.feature_column.bucketized_column(a,\n",
    "       boundaries=[-1000, -115])\n",
    "\n",
    "    feature_layer = tf.keras.layers.DenseFeatures([a_buckets, b])\n",
    "    print(feature_layer(data))\n",
    "    \n",
    "mytest_numeric()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build a simple Keras DNN using its Functional API\n",
    "def rmse(y_true, y_pred):  # Root mean square error\n",
    "    return tf.sqrt(tf.reduce_mean(tf.square(y_pred - y_true)))\n",
    "\n",
    "\n",
    "def build_dnn_model():\n",
    "    # input layer\n",
    "    inputs = {\n",
    "    colname: layers.Input(name=colname, shape=(), dtype='float32')\n",
    "        for colname in NUMERIC_COLS\n",
    "    }\n",
    "\n",
    "    # feature_columns\n",
    "    feature_columns = {\n",
    "        colname: fc.numeric_column(colname)\n",
    "        for colname in NUMERIC_COLS\n",
    "    }\n",
    "\n",
    "    # Constructor for DenseFeatures takes a list of numeric columns\n",
    "    dnn_inputs = layers.DenseFeatures(feature_columns.values())(inputs)\n",
    "\n",
    "    # two hidden layers of [32, 8] just in like the BQML DNN\n",
    "    h1 = layers.Dense(32, activation='relu', name='h1')(dnn_inputs)\n",
    "    h2 = layers.Dense(8, activation='relu', name='h2')(h1)\n",
    "\n",
    "    # final output is a linear activation because this is regression\n",
    "    output = layers.Dense(1, activation='linear', name='fare')(h2)\n",
    "    model = models.Model(inputs, output)\n",
    "\n",
    "    # compile model\n",
    "    model.compile(optimizer='adam', loss='mse', metrics=[rmse, 'mse'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll build our DNN model and inspect the model architecture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9kAAAFhCAIAAADr0P6MAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeUBN6f8H8OcuRQttREkSyXeyDyVKljKMZcxQzdeSoSTGmknZZuzLmEbCjG1MEkOWLzKWCKkUJktSYiQKLdLitt/b+f3x/OZ++1b3dKtb51bv11/uuec85/M8zzmnz3085xwewzAEAAAAAAAaHZ/rAAAAAAAAWijk4gAAAAAA3EAuDgAAAADADeTiAAAAAADcENa4xsmTJ0+ePNkIoQAohJGR0c8//8x1FAAAAAA1q3lc/OTJk9HR0Y0QCkD9paam7tixg+soAAAAAORS87g4IcTa2jo4OLihQwGov+DgYGdnZ66jAAAAAJAL5osDAAAAAHADuTgAAAAAADeQiwMAAAAAcAO5OAAAAAAAN5CLAwAAAABwA7k4AAAAAAA3kIsDAAAAAHADuTgAAAAAADeQiwMAAAAAcAO5OAAAAAAAN5CLAwAAAABwA7k4AAAAAAA3kIsDAAAAAHADuTgAAAAAADcaMBfPzc1tuMIVKyMjIzg4eNOmTVwF0ITaCgAAAAAURfG5eHFx8aZNm6ytrfX09BReOAuGYfz9/b29vUeMGGFra5uUlFR1SbUbJiYmrl+/3tnZ+ciRI7XdqZWVlZeXV51jVkhbRURE+Pj48Hg8Ho/n4uJy7ty5Ohclpxs3bjg6OtI9zp07NyoqqqH3CAAAANAs8RiGYV/DycmJEBIcHCx/oUVFRZ06dcrJyamxcAXauXPnqlWrcnNzRSLR7NmzfXx8oqOjKy2xtLSsdtvi4mI1NTVzc/OnT5+y7yU1NbVz587Sj19//bWZmdmGDRuq/VYeimqrLl26vH79uqCgQF1dvT7lsKhYu8LCQg0NDWNj41evXjXQ7uomODjY2dm5MQ88AAAAgDoTNkShampq+vr6OTk5DVG4LL/++munTp2EQqG2tvaZM2cIIS4uLpWWyNK6dWt5dvHy5UsXF5eIiAjpkuPHj7N8Kw9FtZWamhohpOES8Uq1ozuiOwUAAACAumk+926mpqbyeDz2JfWRlpY2fvz4rKysOnzb1DXv2gEAAABwRWG5eGFhoaenp7u7++rVq1esWFFQUEAIkUgkN2/eXLJkiYmJyZs3b+zs7IyNjXNycvLy8pYvX+7j4+Pp6Tl69GhPT086SSM6OnrZsmUmJibp6emTJ0/W1dXt1avX6dOn6S6q3YoQcuHCBQ8Pj8LCwvT0dA8PDw8Pj+PHj1daIhKJ5K/Ls2fPpkyZ4u3tPWPGDFtb27i4OEJIQEBAQkICLZBWLTg4eObMmcOGDav67f79++l0akJIfn6+r6+v9KOstqKKioq2bdvm6uo6cOBAe3v7x48f0+XXr183MjIKDw+vMXiGYc6dO+fu7m5kZJSTkzNz5kw9Pb1evXr99ddf7C3MEnOl2tW5DYOCgtTV1Xk83tatW8ViMSHk6NGjqqqqAQEB1dZd1vEjZwwAAAAAyo6piaOjo6OjI/s6ZWVllpaWbm5u5eXlDMP8/fffAoGAEFJcXBwVFUVnMmzevPnq1auurq5v3741MzP74Ycf6LYZGRlmZmZdu3Z9//59SEgInS6yYMGC8PDwo0ePampqEkIiIyPz8/Or3Yom8XR+sLm5ecWoqi5hUXHl7t27m5qaMgxTWlqqpaVlYWFRbYF0qrR0SaVvTU1NKzav9KOstqKrubm5JSYm0n87ODjo6+vn5eUxDHP27Fk1NbXz58/Lit/c3JwWUl5enpqaqqGhQQjZuHFjSkoKvSfV0tJSLBaztDBLzHVoXlltuGrVKkJIfHy8tA0nTZokq+6ZmZlVj5+PHz/K2inDMCdOnJDnqAYAAABQBorJxXft2kUISUhIkC4xMzOTpkQ9evQghGRnZ9OPK1euJIS8fftWuvLhw4cJIV5eXtINRSIR/WrHjh2EEGdnZ/atGIXm4r6+vseOHWMYRiKRmJqaCoXCagssLy9nycWlyXGljyxtFRMTU/XHUkhICF2trKyMJf5Ku6NtLo1TX19fVVW14u6qtjBLzFVrV+2SimS14fv37zU1Nd3c3OjHzZs30wqy1L3S8cMOuTgAAAA0IYq5dzM0NJQQYmJiIl3C5/939gud56Crq0s/0kfgtWnTRroCneZx+/Zt6YZ0WJcQMnHixKVLlz5//jw9PZ1lK8Xy9PQUiUR79uz58OFDSUkJnU1RVd0mo7O01b179ywsLOLj46vdUCisRWdVjI3H4+no6GRmZlbcXdUWlr9wechqQz09vYULF/70009r1641NDQMCwujD4VkqXul4wcAAACg2VDMfPE3b94QQrKzs+XaJZ9PCElJSZEu6dChAyFES0ur6sqGhoaEkM6dO9dqq3q6e/du7969TU1N16xZQ6dwKBBLW2VnZycnJ1ecPk4IkUgkig2gEmkLK6rAzMzMsrIyljb09PRUVVX18/OLjY21tLSkvzE4qTsAAAAAtxSTi/fs2ZMQ8ueff8qzMh3PrrhyamoqIcTe3r7qyjRntbe3r9VW9eTi4lJWVjZ27FhCCJ2IwvzzvGpZY+RVv6WjuSUlJbSQvLw8Wg5LW/Xs2ZPevyhdkpCQsHv3bnl2XWfSFmaJWf4AGIaZP3++QCBgacN27drNmzdv7969/v7+s2fPpgvZ6w4AAADQPNU4i0We+eIPHjwQCAS6urqXLl0qKCgICwujk0mSk5MZhunSpQshRHrLXUFBgYWFRadOnaSTvxctWjRkyJDS0lLmnznK0rnRAQEBAwYMKC0tZd+KJpRdu3aVhlR1CQs6HNulSxf6sW3btoSQK1euBAUFtW/fnhASExPz+vXrbt26qaurv3r1iq6Wn59PCDEwMKAfK307adIkQsjq1aufPXv2888/6+joEEIuXbr0119/yWqroqKirl27EkJmzZoVFBS0atUqBwcHeu9mSEiIhobGxYsXZVWBDmxLZ4HTNqe3hzIMQwe/2VuYJWaxWFypdnR039DQUCKRSGPIzc2dM2fOtGnTWNqQrvnu3TtVVVU7Ozvptix1r3T8sMN8cQAAAGhCBGvXrmVP1k+ePEkIcXR0ZFmnY8eOw4cPf/To0e7duw8fPtyxY8ePHz+OHTtWS0vr2LFj58+fJ4S8f//eyMjIwMBARUVlxowZOTk5e/fuffjwYVhYmLa29oEDB1RVVQkhu3fvzs7Obtu2bY8ePUQiUURExK+//qqmpsay1ePHj7du3RobG0vHcXV0dLKysiot6dixo6zgk5OTN27cePfu3by8PG1tbXNzc319/cjIyLi4uGnTppmamtIkcsqUKXl5eYmJif369fvkk08KCgo2bdoUGRkpEonatm1rYWHx4cMH6beEkAEDBty9e/fcuXOPHz9esmRJdHT0sGHDjI2N7ezs7O3tq7aVoaFht27dvvzyy+Tk5NDQ0LCwMCMjoz179tB50q9evbp06ZKTkxNNWCuiTXTx4kVCSEpKilAoDAsL++OPPwghQqGwb9++e/fuPXXqFM3Fhw4dum/fvmpbmCVmc3PzrKwsae2uX7++Zs2apKSkjx8/njhx4vTp04cPH96yZcuqVavu3bu3bNmyfv36tW3btto2pC8J0tTUvHPnzowZM/r27UtrIRQKv/jii0p1b9Wq1datW8+ePVvx+GE/XJ88eXLq1Kkaj2oAAAAAZcBjanpbuJOTEyEkODi4UeIhPXv2TEpKqjEqqDNlaOGCgoK+ffvGxcUp/EWhwcHB9Jkwii0WAAAAoCE0n/dusuPJ9vTpU66ja3H27NmzcOFChSfiAAAAAE2LYp5pqEB06rZIJFLsA0wwUCrVQC0sj5iYGHd398LCQolEgp9AAAAAAEo0Li4SiVauXJmWlkYIWbRoUXR0NNcRNTect7CGhkZ+fj6fzz927FirVq0aee8AAAAAykbp5osD1AfmiwMAAEATokTj4gAAAAAALQpycQAAAAAAbiAXBwAAAADgBnJxAAAAAABuIBcHAAAAAOAGcnEAAAAAAG4gFwcAAAAA4AZycQAAAAAAbiAXBwAAAADgBnJxAAAAAABuIBcHAAAAAOAGcnEAAAAAAG4gFwcAAAAA4IZQnpWio6OdnJwaOhSA8vLyrKwsfX19Ho9XtxJSU1MVGxIAAABAw6k5F3d0dGyEOAAIIdnZ2bdu3VJTUzM2Nu7SpYuWllZtS+jcubO1tXVDxAYAAACgcDyGYbiOAeC/Xr16dfz48QMHDrx48eKTTz5xcXGZOXNmx44duY4LAAAAQPGQi4MyKi8vj4iIOHz48OnTpwsLC8eMGePq6jpu3DgVFRWuQwMAAABQGOTioNSKior+85//BAQEhIWF6evrz5w509XV1czMjOu4AAAAABQAuTg0DW/evAkKCtq7d29KSsqnn37q7u4+bdo0DQ0NruMCAAAAqDvk4tCUSCSS0NDQgwcPhoSEaGhouLi4zJ8/39zcnOu4AAAAAOoCuTg0SRkZGYcPH963b9/Lly9HjRo1f/78iRMnCgQCruMCAAAAqAXk4tCElZeXX79+ff/+/WfOnNHX13dxcVmwYIGRkRHXcQEAAADIBbk4NAcvXrzYu3fvoUOHRCKRk5OTp6dn//79uQ4KAAAAoAbIxaH5KCoq+uOPP3bu3BkXFzdixAhPT8/PP/+cz+dzHRcAAABA9ZCmQPOhpqY2e/bsR48eRUREaGhoTJw40dzcfOfOnYWFhVyHBgAAAFANjItDs/XkyZMdO3YEBQW1bdv222+/Xbhwoa6uLtdBAQAAAPwXcnFo5jIyMvbs2bNnz57S0lIPDw9PT08DAwOugwIAAAAgBLk4tBAikei3337bvn17VlaWs7PzmjVr8PJOAAAA4Bzmi0OLoKmpuXjx4uTk5AMHDsTExPTs2dPJySkhIYHruAAAAKBFQy4OLYiqqqqLi0tCQsLvv/8eHx/fu3fvKVOmPHr0iOu4AAAAoIVCLg4tjlAodHFxiY+PP3ny5MuXL/v37z958uS4uDiu4wIAAIAWB7k4tFB8Pv+rr76KjY0NDQ19/fp1v379JkyY8ODBA67jAgAAgBYEuTi0dPb29vfu3QsNDX337t2nn36KjBwAAAAaDXJxAEL+ychPnjz56tWrgQMH/vvf/05MTOQ6KAAAAGjmkIsD/D8ejzd58uRHjx6dPXs2KSmpV69eTk5OL1684DouAAAAaLaQiwP8Dx6PN2HChL/++uvIkSP379//5JNPFi1alJGRwXVcAAAA0AzhXT8AMpWVlf3+++/r1q3Ly8tbsGCBj4+PtrY210EBAABA84FcHKAGpaWlAQEBa9asEYvFy5cvX7hwobq6OtdBAQAAQHPwP7l4cXHxxYsXJRIJhwEBNIRBgwaZmJjUp4Tc3NyffvrJz89PS0vrhx9+mD17tlAoVFB0AAAA0EL9Ty5+5syZyZMncxgNQAP5+uuv//jjj/qXk5GRsWnTpn379nXr1m3r1q0TJ06sf5kAAADQYv3PvZtisZgQwgA0L46Ojor6354OHTr4+/s/f/584MCBkyZNsra2joqKUkjJAAAA0ALhOSoAtWZsbBwYGHjnzp1WrVrZ2tri0YcAAABQN8jFAepo0KBBN2/eDA0NTUxM/Ne//jV37tzMzEyugwIAAICmBLk4QL3Y29vfv3/fz8/v7NmzPXv23LFjR1lZGddBAQAAQNOAXBygvlRUVObPn//333/Pmzdv5cqVffr0uXz5MtdBAQAAQBOAXBxAMdq0abNp06bnz58PGjRo7NixDg4OT5484TooAAAAUGrIxQEUycjIKDAw8MaNG5mZmf3791+8eHFeXh7XQQEAAICSQi4OoHjDhw9/8ODBwYMHjx8/3q1bt507d+IVWgAAAFAVcnGABsHn811cXJ4+ferm5rZ8+XJLS8vIyEiugwIAAADlglwcoAHp6Ohs3bo1Li6uQ4cOtra2EyZMePXqFddBAQAAgLJALg7Q4MzNzS9evHj+/PnExMRPPvlk7dq1RUVFXAcFAAAA3EMuDtBIJkyYkJiYuHnz5h07dvTo0SMwMJBhGK6DAgAAAC4hFwdoPCoqKosXL3769Onnn38+a9askSNHPnr0iOugAAAAgDPIxQEam4GBwb59+27fvl1YWPjpp58uXLgQzz0EAABomZCLA3DDysoqJibm4MGDJ06c+Ne//nX8+HGuIwIAAIDGpphcPDc3VyHlNIKMjIzg4OBNmzZxHUjNmlCrQt3weLxvvvnm2bNnjo6O06ZNGzFiRGJiItdBAQAAQOOpVy5eXFy8adMma2trPT09RQUkD4Zh/P39vb29R4wYYWtrm5SUVHVJtRsmJiauX7/e2dn5yJEjDReelZWVl5dXnTdXSKtGRET4+PjweDwej+fi4nLu3Lk6FyWnGzduODo60j3OnTs3KiqqoffYbGhra+/cufPu3bsikahv374+Pj7FxcVcBwUAAACNgqngxIkTlZbUqLCwUEdHp7Zb1ZOfn5+GhkZZWVlOTs6XX355586dqktkbUufJWdubt5w4Tk7O69evVr68fXr17UtQVGtamxsTAgpKCioZzksKtauoKCAEGJsbNxwu6sbR0dHR0dHrqOoWVlZmZ+fX5s2bbp163b58mWuwwEAAIAGV985Kmpqavr6+vUspLZ+/fXXTp06CYVCbW3tM2fOWFpaVl0ia9vWrVs3dHjHjx/fsGED/ffLly+nTp1a2xIU1apqamqEEHV19foXVa1KtaM7ojuFOhAKhfQpK0OGDBkzZsyECRPS0tK4DgoAAAAaUJO8dzM1NZXH47EvUQZpaWnjx4/PysriOpAG0bxrxyFDQ8PAwMALFy48efKkV69eO3fulEgkXAcFAAAADaIuuXhhYaGnp6e7u/vq1atXrFhBZyZIJJKbN28uWbLExMTkzZs3dnZ2xsbGOTk5eXl5y5cv9/Hx8fT0HD16tKenZ05ODsMw0dHRy5YtMzExSU9Pnzx5sq6ubq9evU6fPk13Ue1WhJALFy54eHgUFhamp6d7eHh4eHgcP3680hKRSCR/XWSFd+7cOXd3dyMjo5ycnJkzZ+rp6fXq1euvv/6iWzEMs2vXrunTp8+bN69Vq1a8f0gkkuDg4JkzZw4bNowQEhAQkJCQQAMjhOzfv5+uRgjJz8/39fWVfpTVqlRRUdG2bdtcXV0HDhxob2//+PFjuvz69etGRkbh4eE1VpOlRux9wRJzpdrJ49mzZ1OmTPH29p4xY4atrW1cXBwhJCgoSF1dncfjbd26VSwWE0KOHj2qqqoaEBBQbd1lHWlyxtBUjBs37smTJ0uWLPH29h40aNCdO3e4jggAAAAaQMUJK/LMFy8rK7O0tHRzcysvL2cY5u+//xYIBISQ4uLiqKgoOj9h8+bNV69edXV1ffv2rZmZ2Q8//EC3zcjIMDMz69q16/v370NCQuh0kQULFoSHhx89elRTU5MQEhkZmZ+fX+1WNEtmGIZUmfBddQkL6cqydvThw4fU1FQNDQ1CyMaNG1NSUui9npaWlnRNf39/Pp///v17hmE2b95MCPH09KRfvXr1qmIwlQIzNTWt2MLSj7Jala7m5uaWmJhI/+3g4KCvr5+Xl8cwzNmzZ9XU1M6fPy+rpubm5rSQ8vJyWTUSi8UsfcEScx06onv37qampgzDlJaWamlpWVhY0OWrVq0ihMTHx0vbcNKkSbLqnpmZWfVI+/jxo6ydMk1nvni1nj17Zm9vz+fz3d3dc3NzuQ4HAAAAFKnWufiuXbsIIQkJCdIlZmZm0q169OhBCMnOzqYfV65cSQh5+/atdOXDhw8TQry8vKQbikQi+tWOHTsIIc7OzuxbMYrLxdl3ROtCl5eXl+vr66uqqtKPEyZM4PF4JSUlDMPQUWorKyvpmiy5uDQ5rvSRpVVjYmKq/oIKCQmhq5WVlbHUtNLuWGokqy9YYq5au2qXVOTr63vs2DGGYSQSiampqVAopMvfv3+vqanp5uZGP27evJlWkKXulY40dk06F6eCg4P19fU7dux4+PBhrmMBAAAAhan1HJXQ0FBCiImJiXQJn//fQujsBV1dXfqRPtiuTZs20hXo5I3bt29LN6SDtYSQiRMnEkKeP3/OvpUCse+o4gR0Ho+no6NTWlpKPzo4ODAM8+eff5J/bgYdOXKkdM06RMLSqvfu3ZOOH0uNHz+efisUCuXfC0uNZPVFHerCwtPTc8KECXv27Nm0aVNJSQmdkUII0dPTW7hw4eHDh9+8ecMwTFhY2JgxYwhr3Ssdac2eo6NjYmLi+PHjv/nmm88++yw5OZnriAAAAEABap2Lv3nzhhCSnZ0tV+l8PiEkJSVFuqRDhw6EEC0traorGxoaEkI6d+5cq63qo847WrBgwYEDB1xdXb/77rtly5atW7du/fr19YmEpVWzs7OTk5MrTh8nhDT0zXzSvlBUgZmZmWVlZXfv3u3du7epqemaNWvoNBgpT09PVVVVPz+/2NhYS0tL+huDk7orLV1d3QMHDkRGRr5796537947duxosU0BAADQbNQ6F+/ZsychhA4J14gOM1dcOTU1lRBib29fdWWaidrb29dqq/qo844kEkl8fHxMTMxPP/107ty577//nmV8Wjr6S/4ZzS0pKSGElJeX5+XlEUIYhmFp1Z49e9L7F6VLEhISdu/eXbVwBZL2BUvM8gfAMMz8+fMFAoGLi0tZWdnYsWNpURXLadeu3bx58/bu3evv7z979my6kL3uLdOQIUNiY2O///77FStWDBo06P79+1xHBAAAAPVQ8X//5Zkv/uDBA4FAoKure+nSpYKCgrCwMDrHIzk5mWGYLl26EEKkN9IVFBRYWFh06tRJOid70aJFQ4YMKS0tZf6ZeSyd8RwQEDBgwIDS0lL2rWia2LVrV2lIVZewoIOsXbp0qTE8Whd6MyXDMHSomH61bt06U1PTgwcPXrp0KSoqKikpSVqL/Px8QoiBgQH92K1bN3V19VevXtGPkyZNIoSsXr362bNnP//8M32hz6VLl/766y9ZrVpUVNS1a1dCyKxZs4KCglatWuXg4EDv3QwJCdHQ0Lh48aKsytKBbekscJYayeoLlpjFYnGl2tHRfUNDQ4lEIo0hNzd3zpw506ZNYximbdu2hJArV64EBQW1b9+eEBITEyN9W9C7d+9UVVXt7Oyk27LUvdKRxq4ZzBev6tmzZ3Z2dioqKt7e3sXFxVyHAwAAAHVRl/duhoeHDxkyRFNTs2vXrlu2bLG1tZ07dy4dHqb5/Zw5c+7fv09Xzs/P9/LycnBw8PT09PLyWrdunTRvoPnf9u3bs7KyMjIytmzZIk2tZG0VFxc3d+5cQgiPx1u7du3Dhw+rLmGJ/MWLFwsXLqRB7tix48OHD7J2JB183bBhQ25uLr2XkRDi7e1dWFgYGhpa6V087dq1O3XqlEgk8vHxoUt8fX3z8vJ8fHw6dux46tQpGkBSUpKlpaW6urqDg0NSUpKNjc306dP/+OOP4uLialv12rVrYrH45cuXEyZM0NHR6dChw5w5czIzM2lpoaGhBgYGYWFhVWt669Ytb29vGsnUqVPPnj3LXiOWvmCJuWLtwsLC6CxzQoi5ufnw4cOHDx/eo0cPVVVVQkhAQABt1bZt2w4aNCg6OtrPz09bW3vixIn0cTTUuHHjAgMDK1akat1FItG6deuqHmksmmUuzjBMeXn5vn372rRpY2FhER0dzXU4AAAAUGs85p9JAoSQ4OBg+ugM+YfV66Nnz55JSUmNtjtFYRjm999/f//+/fLlywkhEonk7du3N27c+O677zIzM7mOro6UoS8KCgr69u0bFxen8BeFOjk5EUKCg4MVW6ySSElJoT/b3NzcfH19K03EBwAAAGXWJN+7yY4n29OnT+tfPn31jKurK/0oEAg6d+5sY2PTqVOn+hfeku3Zs2fhwoUKT8SbPRMTkytXrhw/fvzMmTO9e/emz+QBAACAJoHLXJxO3a7VazLlwfK/APQWyXqKjIwkhOzdu/f9+/d0SWxsrI+PT1BQUP0L50oD9YU8YmJi+vTp0717919//VX+V3hCJY6OjvHx8ba2tp999pmTk5OcTzoCAAAAbnGTi4tEopUrV6alpRFCFi1aFB0dzUkYdXP48OEFCxb89ttvRkZGQ4YMcXR0vH//flBQkIWFBdeh1QXnfaGhoZGfn8/n848dO9aqVatG3ntz0qFDh8DAwJCQkOjoaAsLi8DAQK4jAgAAgBpwOV8coHE07/niVeXl5S1fvvzAgQPjxo379ddfjYyMuI4IAAAAqtcM54sDtHBaWlr79u0LDw9/9uxZr1699u/fjx/YAAAAygm5OEDzZGtr+/DhQw8Pj/nz53/22Wf0PVYAAACgVJCLAzRbampqW7dujYyMTE1N7d27d0BAANcRAQAAwP9ALg7QzA0ePPjBgwceHh5ubm5jx46lr0cFAAAAZYBcHKD5a9269datWyMiIpKTk+kMcq4jAgAAAEKQiwO0HNbW1g8fPpw7d+68efPGjx//9u1briMCAABo6ZCLA7QgdAZ5eHh4UlJSv379Tp06xXVEAAAALRpycYAWx8bGJjY29ssvv3RycnJycpK+QRYAAAAaGXJxgJaobdu2+/btu3z5ckxMTK9evf7zn/9wHREAAEBLhFwcoOUaPXr048ePv/jii6+++srJyenDhw9cRwQAANCyIBcHaNHoSzovXrx4+/ZtCwuL8+fPcx0RAABAC4JcHADI2LFjHz16ZGdnN2nSpLlz5xYUFHAdEQAAQIuAXBwACCFET0/v+PHjx48fP336dP/+/e/cucN1RAAAAM2fsOqikydPNn4cAJWUlJR8+PDBwMCg/kWlpqZ27ty5/uW0BE5OTnZ2dq6urjY2NsuWLduwYYOKigrXQQEAADRb/5OLGxgYCIVCJycnrqIBaCDW1tZch9BkdOjQISQk5MCBA56entevXw8KCurRowfXQQEAADRPPIZhuI4BoBoSieThw4fXrl2LjIy8detWfn6+gYGBjak9u9YAACAASURBVI2Nvb29g4ND165duQ6w+UtMTJw+fXpiYuKWLVsWLVrE4/G4jggAAKC5QS4OTYBYLH706NG1a9euXbsWFRVVVFQkzcs/++yzLl26cB1gsyUWizdu3Lhx40Z7e/vff/9dIVOGAAAAQAq5ODQxFfPyyMjI4uJiU1PToUOH2tjYjBkzxtjYmOsAm6Ho6GgXF5e8vLwDBw588cUXXIcDAADQfCAXhyasqKgoNjY2Kirq2rVrERERJSUlpqam9vb2Q4cOHTlypJGREdcBNh/5+fleXl779++fMWPGL7/8oqmpyXVEAAAAzQFycWgmCgsLb9++HRkZGRUVdevWrdLSUpqX29vbjxw5Uk9Pj+sAm4PTp0/PnTu3bdu2gYGBNjY2XIcDAADQ5CEXh2aooKAgOjqaTmK5e/duWVmZNC8fNWqUrq4u1wE2YRkZGa6urleuXMETDwEAAOoPuTg0cyKRKCYmhs4vf/DgASGkZ8+e9L5Pe3t7HR0drgNsehiG2b17t7e3d58+fY4dO2Zqasp1RAAAAE0VcnFoQT5+/Hjnzh1pXs7j8fr160fv+xw9erSWlhbXATYlCQkJ06ZNS05O/uWXX6ZNm8Z1OAAAAE0ScnFoobKysmJiYuh9n/fv3+fz+f369aP3fdrZ2bVt25brAJuAkpKSH374Yfv27ZMnT96/f7+2tjbXEQEAADQxyMUBSGZmZnh4OL3v8/79+wKBoG/fvnQSi42NTevWrbkOUKldvXp15syZqqqqR48eHTp0KNfhAAAANCXIxQH+R3p6ekREBL3vMyEhQSgUSvNyW1vbVq1acR2gMsrMzJw1a1ZoaOiqVavWrFkjEAi4jggAAKBpQC4OINO7d+8iIyOvXbt29erVly9fqqur9+/fn973OWzYMFVVVa4DVCIMw/j7+y9fvnzo0KFHjhzp1KkT1xEBAAA0AcjFAeTy9u1bOrn8ypUrr1690tDQsLa2pvd9Ii+Xio2NnTp16ocPH3777beJEydW/Ordu3ezZ8/29/c3MzPjKjwAAABlg1wcoNaSk5Pp5PJLly6lpqbSvJze92llZdXCH7ldVFTk4+Pj7+8/Y8aMvXv3qqurE0LKy8tHjhwZHh4+aNCg6OhoTGIBAACgkIsD1EtycjKdXH79+vU3b95oamoOHjyYzi/v378/n8/nOkBunD59es6cOQYGBseOHevbt+/69evXrVtXXl4uEAg2b968fPlyrgMEAABQCsjFARSG5uXXrl27fv16dnZ2mzZtrKysaF4+YMAAHo/HdYCNKiUlZerUqQ8fPly8ePGPP/5YXl5Ol6uoqMTGxvbu3Zvb8AAAAJQBcnGABiHNy8PCwj58+NC+fXsrKyt636f8eXlxcfHIkSNnzpzp7u7eFFN5sVjs7e3922+/iUQiiURCFwqFwp49e96/f7+FT+YBAAAgyMUBGppEInn69Cm97/Pq1au5ubkdOnQYNmwYve/z008/Zdn2+vXro0aN4vF4tra2hw8fNjExaayoFYNhmAkTJoSGhpaVlVVcLhAI1qxZ88MPP3AVGAAAgJJALg7QeCQSycOHD+l9n6GhoXl5eR07drS1taXzWExNTSutv2bNmh9//LG0tFRFRYXP569bt87Ly6sJzUH/8ccffXx8qr3ICASCmJiYgQMHNn5UAAAAygO5OAA3xGLxo0eP6H2f4eHhHz9+NDAwoJNYRo8eTYfArays7t69K92Ez+cPGjQoMDCwR48enMUtt5iYGBsbG+nUlEqEQmH37t0fPnyI1ycBAEBLhlwcgHslJSV37ty5cePGjRs3YmJiSkpKunfvbmtre+TIEbFYXHFNFRUVHo+3fv367777TsmfDLh06VI/Pz9VVdXS0tJqVxAIBF5eXlu2bGnkwAAAAJQHcnEA5VJUVBQdHX3jxo3z58/HxcVVuw6fzx84cGBgYKC5uXkjh1crT548OXny5OnTp+Pj41VUVMRicaULDo/Hu3Xrlo2NDVcRAgAAcAu5OICSWrlypa+vr6xB5SY0QE4ISU5ODgkJ+eOPP+7evcvn83k8Hh3vFwgExsbGT548UVNT4zpGAAAADiAXB1BSAwcOjI2NZV+Hz+d/+umnR44cUfIBcqn09PTz58+fPn36xo0bYrGYz+dLJJLFixf7+flxHRoAAAAXGFZGRkZcBwhQa0Kh8NatW+zHNoeWLl3KdQsBNCAjIyOuT7L/unXrllAo5LpJlNfSpUu57qL/wrWRhbL9XUN+WB+VzrsarlBpaWlLly61trZunOAAFMLJyendu3dcRyFTWlra4MGDPT09WdZ5/Pjxhg0b+Hy+9HWVhBChUKihoaGjo6Ojo6Otra2tra2lpdW2bVtDQ8Oqz0NsKiQSSUZGhqGhIdeBgGJER0fv2LGD6yj+6927d2KxODg4mOtAlNHPP/+clpbGdRT/Jc+1scVStr9ryA/rrOp5V/NoweDBgx0dHRssJICWqHPnzuyn1fDhw1u3bq2trW1gYNC+ffv27dsbGhq2adOm0SIEqBtGKec94q9YtU6ePMl1CJXVeG0E5YH8sG6qnnf4nzsAZdS+ffuVK1dyHQUAAAA0rCbzAj8AAAAAgGYGuTgAAAAAADeQiwMAAAAAcAO5OAAAAAAAN5CLAwAAAABwA7k4AAAAAAA3kIsDAAAAAHADuTgAAAAAADeQiwMAAAAAcAO5OAAAAAAAN5CLAwAAAABwA7k4AAAAAAA3kIsDAAAAAHADuThAk5Gbm8t1CADNVl5eHtchgLzQWdCcIBdvDiIiInx8fHg8Ho/Hc3FxOXfuXEPv8caNG46OjnSPc+fOjYqKaug9tmTFxcWbNm2ytrbW09PjOhZCCGEYxt/f39vbe8SIEba2tklJSVxHVGtXr14dO3YsPYBHjBgxYsSIgQMHTpw48eDBgyUlJY0Wxvbt27W1tXk8nkAgGD169Pjx48eNGzdq1ChjY2Mej/f69etGi6SF2759+7Bhw1jOrzdv3hw6dMjJycna2lrOMpXkGGt+2DuLYZiDBw/269dPU1Ozb9++hw4dYhimxjLRWQ2nMf9eNOF+ZFgRQk6cOMG+DjSc169fy7+ysbExIaSgoKBx4ikoKCCEGBsbN9zu6oyT4/bRo0fz58+/evWqWCxmX9PR0dHR0bFWhRcWFuro6NR4wjYOPz8/DQ2NsrKynJycL7/88s6dO7UtoVYHdgNJS0sjhJiYmNCPEonk/Pnzpqam3bt3j4+Pb7Qw3rx5Qwjp3r17xYUSiWTcuHF///13HQrkvG1PnDjROAfq8ePHV6xYERcXV/94ioqKdHV12Vd79eoVIcTc3Fz+CJXkGGNRh2tRHeTn57u7ux87dkwkEtU/HvbO8vb2njZt2u7duxctWtS6dWtCiL+/vzxBKn9nNc7ftejo6AULFoSHh0skEoXEU/+/F7Wi/P3IVHecY1xceb18+XLq1Knyr6+mpkYIUVdXb5x46I7oToEQEh4e/ssvvzg4OHTo0GHJkiV37txRYOFqamr6+voKLLA+fv31106dOgmFQm1t7TNnzlhaWtZq89oe2A2kU6dOhJBWrVrRj3w+f8KECRERESKRaOLEiUVFRY0ThoGBASFEIBBUXMjn81esWKGpqVnb0pSkbRtHcHDwli1b+vTpY25uvnnz5pcvX9a5qNatW7dv3559HTrYUStKcoxxLjk5ef/+/VOnTtXT0/v6668vXLhQWlpa59JYOis1NTU1NTUoKOjbb7/duXPn2bNnCSE7d+6Up1h0FnX16tXdu3fb2dkZGBh4eXk9ePCgngXW8+9FbTXRfkQurqTS0tLGjx+flZXFdSD/T9niUU6qqqqEkOzs7F9++WXw4MEGBgaLFy+u/7VM2aSmpvJ4vLptq+QHkqGh4YYNG5KTk319fRtnj9W25MOHD4cOHdqhQ4daFaXkbdtwnj17tnbtWlNTU3Nz823btqWnp3MdEZvGP8aUR0lJyZkzZyZOnKirqztjxoyQkBCxWKzA8l+9elWxVUePHt2uXbvMzMw6F9gyO4smspmZmf7+/gMGDDAyMvLx8anz3JL6/L1QFOXvx3rl4gzDREdHL1u2zMTEJD09ffLkybq6ur169Tp9+jRd4dmzZ1OmTPH29p4xY4atrW1cXBxdfu/ePSsrq2+//XbNmjVCoVAkEslaWFRUtG3bNldX14EDB9rb2z9+/JhhmHPnzrm7uxsZGeXk5MycOVNPT69Xr15//fWXNKpdu3ZNnz593rx5rVq14v2j2tIkEsnNmzeXLFliYmLy5s0bOzs7Y2PjnJwcllqLRKINGzZMnz590aJFdnZ2fn5+DMMQQvLy8pYvX+7j4+Pp6Tl69GhPT09azv79+6UB5Ofn+/r60o/sFQkICEhISEhPT/fw8KD7vX79upGRUXh4uDz9Iqtk9i6TFWq18dSo2t4PCgpSV1fn8Xhbt26lV+GjR4+qqqoGBAQoqoOUQVlZGSEkPT197969AwYMMDMzW7t27YsXL2pVSGFhoaenp7u7++rVq1esWEEnBVF1OC/kPL/YQ7pw4YKHh0dhYSE9Ejw8PEQikaxCqj0AKh1Isg45Wf0ua1/V1k7+U6aiKVOm8Pn80NBQTpq6tLT08ePHCxculLV3JWlbZUPPuOfPn69atcrQ0NDa2nrnzp3v37+vbTmZmZn0qmhhYXHv3r0a12+Kxxi3ysrKGIYpKCgIDg6eOHGioaHh4sWLIyMjGTlmdVdStbNsbGw6duxYcZ3S0lJbW1v6b3RWbdH/vnjz5o2vr2/Pnj3Nzc3Xrl2bkpIi5+bV/r2oeu2q7RWpefYj+6QWwjofSCwWh4SE0ClZdILR0aNH6f+r0lOre/fupqamDMOUlpZqaWlZWFjQDc3MzHR0dMrLyxmGcXJyysjIkLXQzc0tMTGRbuXg4KCvr5+bm5uamqqhoUEI2bhxY0pKypEjRwghlpaWdDV/f38+n//+/XuGYTZv3kwI8fT0pF9VLS0zMzMqKopOtNi8efPVq1ddXV0/fvwoq8qlpaV2dnbTp0+nU6kOHTpECDl//nx+fr6ZmdkPP/xAV8vIyDAzM+vatWtOTg7DMKamphWbmn4sLy9nrwj537mJZ8+eVVNTO3/+vKzYzM3N6V5YSq6xy6oNtdp4ql1SkazeX7VqFSFEOnPr1atXkyZNov+ufwdJA2v8+eL+/v50XLxaQqGQENKnTx8/P78JEybUOCeyrKzM0tLSzc2NnhF///03ncZAv63DeSHn+ZWXl1djTSv1u6xCZB0AlTav9pArLi6utt9l7ava2tV4ysg6gDt27Kirq9toTV31aNHS0lLytmXRaPPFv/rqK1mnm0AgEAgEQqFw7Nix3377rTzx0Ovn999///LlywsXLhBCBg8eXGmdqgdMUznGZGmc+eIPHz6U1VOEEBUVFUJIp06dvL29x4wZI0888nQWwzCRkZGtW7eOjY2lH5t6ZzXO37X169dLJ3hUwuPxVFRUeDyepaWln5+fnPFUatWq167aXpGaej8y1Z13Crh308zMjBAivSdjx44dhBBnZ2eGYXx9fY8dO8YwjEQiMTU1FQqFdJ127doRQvz8/CQSyePHj2noVRfGxMRUPRpCQkIYhunRo4f08lpeXq6vr6+qqko/TpgwgcfjlZSUMAxDf6NYWVkxDFNjadnZ2TW2IP0PjqdPn9KPZWVlhw4d+vDhw8qVKwkhb9++la55+PBhQoiXlxdTIUumKn5kqUjV44mOKMhSaS8sJbN0GUuoVeORdcRTsnr//fv3mpqabm5u9OPmzZtpLyikg6SBNT4VFRWWXJyig5R8Pn/s2LHsVdi1axchJCEhQbqE9po8DUXXr9TptTq/amxeab+zFCLrACD/e9jUeHZI+51lX9VeUpiaThki4wA2MjIyMDBotKauGIZYLH727FmfPn2Uv21lobl4I6ATQ+XEHrO0ceggS3l5ua6urpqaWqV1SHUHTJM4xmRxdHSkRSkPaerDQp7OKisrGzZsGD1NKi5kKZYod2eRRrlBq0OHDrJycSnpnJN9+/axx1y1VWVdu+S/IjFNvB+Z6nJxYa06qVp8Pp8QQn9MEEImTpy4dOnS58+fE0I8PT1FItGePXs+fPhQUlIinRn266+/zpo1a8mSJUeOHNm9e3fbtm2rXXjv3j0LC4v4+PiqO604/YjH4+no6EjnhDk4OISEhPz5559ffvklHQAeOXIkIaTG0uit2exu3rxJCDEyMqIfhULhrFmzCCH0oX5t2rSRrjls2DBCyO3bt9kLZKlIVXRsVU4sJbN0mQLJ6n09Pb2FCxf+9NNPa9euNTQ0DAsL8/LyIgrqIKmlS5fK//Qxhbhy5Qr9GV0t+tw6iUQydOjQkpISaePLQv8rzcTERLqE9hqRo6Gk/67Y6bU6v+THUoisA0B+lfqdZV/VXlJILU8ZqrS0NCMjw97enn2PDdTUAoHAzMyMDuUqeduyCw4Orm1ItfXLL7/Qp9BUi54vQqFwwIAB1f7JZNmKx+O1b99ezgmyTe4Yq8TCwoIebw3n1atX9CIvi4qKSllZWffu3Vu3bk3vZpYHe2etW7du1KhR//73vysubOqdNX/+fCsrq9puVSsXLlxg+TnN4/H4fD7DMCNGjLh+/bqWllZty5d17ZL/ikSafj9WpYBcvBJDQ0NCSOfOnQkhd+/edXZ2/uWXX7799tujR49K15kyZUr//v3nz58fGhpqa2t74MCBb775purC7Ozs5OTkgoKCiomLRCKp9MyBShYsWKCmpubq6hoVFfX8+fN169bRQeu6lVZJRkYGIeT58+f9+vWruJxeFFJSUnr16kWX0Puu6nCkNr6KXaYQmZmZOjo6Dx48qLb3CSGenp7+/v5+fn7Ozs6Wlpb0vFJIB0kNHjzY0dGxnhWplfT09GpzcaFQKBaLu3fvPnXq1JkzZ3bt2tXJyanG0miSkZ2dLf3hJ1W3hlLU+SV/MLJO/zpj2Ve1l5S67eX69etlZWWjRo1i3yNLCfVvand3d/a9K3/bNsLZd/z48aoLpbmCpaXlrFmzvv7668uXLzs7Ozd0MLWiDMeYlL6+fkN31qNHj6pdrqqqWlpa2r59+3//+9+Ojo42NjbyXBvlERISoqGh4ePjU/+ilKqzLC0tG7qznj59Wu1y+nvJzMxs9uzZM2fO7Nixo/R2lFqR89ql2HyAKFk/VqX456hkZ2cTQuiPDxcXl7KysrFjxxJCysvLCSH0vw++//77bt26Xbly5dixY2KxePXq1dUu7NmzJ50XLy08ISFh9+7d7AFIJJL4+PiYmJiffvrp3Llz33//PU316lZaJX379iWEbNq0iVaHEJKSknLx4kU6Cv7nn39K10xNTZW2Az1e6aPmy8vL6QvDGDmmUlQa7lLsLedSFbuMPVR5AmAYZv78+QKBQFbvE0LatWs3b968vXv3+vv7z549my5USAcpD+kkyGXLlj19+pQ+6qFr165ybt6zZ0/yv0dUxa/q0FCKOr/kD4blAKh4IMl/drDsq9pLCqn9KVNSUrJy5cp+/fotWrSIfY8satXULNcBJW9bpUJnshJC+vTp4+vr+/bt2+joaHd3dzlH8etD+Y8xZUP/Irdp08bZ2fnq1asZGRk7d+60sbFRVPmhoaFpaWkVE3Hpf1Cjs2qLTrzs3r37ypUrnz17lpSU5O3tXekG2VphuXZVxN5EzbAf2Se1EDnmi9OZW9LpOwEBAQMGDCgtLWUYhl4Hr1y5EhQURB8IGhMT8/r1azU1tQ8fPjAMU1pa2rZtWzo/rOrCoqIimrvMmjUrKCho1apVDg4OdLZily5dCCF0Ej3DMHRkl+503bp1pqamBw8evHTpUlRUVFJSEo2txtJqvCOQYZgXL17Q52qPGDFi9+7dq1evdnd3l0gkBQUFFhYWnTp1kk4ZX7Ro0ZAhQ2hIkyZNIoSsXr362bNnP//8M31py6VLl8RiMUtFunXrpq6u/urVK/oV/aF/8eJFWbHRgW3pLHCWklm6jCXUSvHQgVtDQ8OKbwTIzc2dM2fOtGnTWHqfrvnu3TtVVVU7OzvptgrpIEqe41bh6E3DNCFo3779smXLpPcMVSLP/VIPHjwQCAS6urqXLl0qKCgICwujM6CSk5Prdl7U6vxiQX+5de3alX5kKUTWAVDpQKrx7JD2O8u+qr2ksJ8y9Lk0Xbp0kS6JjY21tbU1MTF58uRJjXtUVFN//PiRENK5c+eqESpz27Jo5Hs3aWL3ySef/Pjjj9KK1yEeOjVCevzTbKPiNYceMJXeytQkjjEWjXnvJp/P5/F4ampq06dPv3TpUrVTfuWMh6Wzrl69OmLEiF3/8Pf3X7JkyapVq5im31mN83dt/fr1AoGA/iEzNDRkeZ2WPPFU+nvByL52yX9Faur9yDTQvZs0sdu+fXtWVlZGRsaWLVukrUmn1AwaNCg6OtrPz09bW3vixIn0OVP9+/ffsmXL1KlTx40bl5ycTPdVdeHLly8nTJigo6PToUOHOXPmZGZm0mLpD4kNGzbk5ubSWw8JId7e3oWFhaGhoZXeitKuXbtTp05VW5pIJFq3bh1dbc6cOffv36+xEePi4kaPHq2trU0fxpSbm0uX5+fne3l5OTg4eHp6enl5rVu3rri4mH6VlJRkaWmprq7u4OCQlJRkY2Mzffr0P/74Q/qoy2or4uPj07FjRxo5wzChoaEGBgZhYWFVQ7p165a3tzfddurUqWfPnmVvIpYukxVqcXFxxXjCwsImTpxIyzQ3Nx8+fPjw4cN79OhBf0MHBASw9L407HHjxgUGBlasiEI6iOEoFz99+rSurq67u/vNmzfZ31gm59+b8PDwIUOGaGpqdu3adcuWLba2tnPnzr127ZpYLK7DeSH/+cUiLi5u7ty5hBAej7d27dqHDx+yFCLrAKh0YFd7yB08eJBOLavU77L2VW3tWE6ZiIgI6X/I2NnZjR49esKECV999dXu3bsr/eRr0KaOioqShuHt7V31x5vSti2LRsvFFy9ebGxsvGbNmoq3ONchHolE8uOPP9IGWbx48cePH6UDXZ6envQyfv369Tlz5hBChELhtm3bHjx4QLdV/mOMXePk4qmpqfQQDQ4OLiwsrE887J11/fr1au9upK+wbeqd1Th/1w4dOtSuXbsFCxZERUVJU9K6xVPt34uq165Ro0bR4Wo5r0hNvR+Z6o5zHsM6U4LH4504cYJ9ClfPnj2TkpLYy2k0DMP8/vvv79+/X758OSFEIpG8ffv2xo0b3333XX0e+N/MKEOXFRQU9O3bNy4uriFeFCrPccshGlgj3NwG0PiCg4PpQ5m4DuT/KVs8SkXZrkXKFo9SUba/a8oWTxNS9Thvbu/dpA9dd3V1pR8FAkHnzp1tbGxq9fQrnmyybmuA2tqzZ8/ChQsbIhGHesLxDwAA0GgU8BwVOjtHJBLRV8ZwKzIykhCyd+/euXPn0odBxsbGbtu2LSgoSP5Cmv0ICoddFhMT4+7uXlhYKJFIkNgpp2Z//AMAACiPeo2Li0SilStXpqWlEUIWLVoUHR2toKjq7vDhwwsWLPjtt9+MjIyGDBni6Oh4//79oKAgCwsLrkNTCpx3mYaGRn5+Pp/PP3bsWI0vFAAAAABo3uo1Lq6pqbl582b6nnkloaenR++e5joQJcV5l/Xu3TslJYWrvQMAAAAoleY2XxwAAAAAoKlALg4AAAAAwA3k4gAAAAAA3EAuDgAAAADADeTiAAAAAADcQC4OAAAAAMAN5OIAAAAAANxALg4AAAAAwA3k4gAAAAAA3EAuDgAAAADADeTiAAAAAADcQC4OoIwYhnn+/HlmZibXgQAAAEADEnIdAABUIzQ0dMyYMYQQgUCgra3drl27zp07GxgYtG/f3sDAQF9fv+I/VFRUuI4XAAAA6qKGXFwoFDo7Ozs7OzdONACKIhQq7+9MgUBw/PhxHo8nz8oSiSQ7Ozs7OzspKamhAwNQCKU6+2gwcp5uLdDXX3/NdQj/VatrYwukbGcW8sM6q3Te8RiGYVk7IiIiPT29gUMCUDCBQPD555+3bt2a60Cql5KScu/evRpXmzdvXnZ2Nvs6PB5PIBBMmzZt3LhxCoquYZWUlDx+/Dg2Nvbu3bsfP34khKiqqvr6+nbo0IHr0EBhOnbsaGtry3UU/6+4uPjixYsSiYTrQJTUoEGDTExMuI7i/8l5bWyZlO3vGvLD+qh03tWQiwMAV9zc3AIDA8vKymStwOfzP/3008DAwJ49ezZmYHWQlZV16dKlc+fOXbp0qbi4WCgU0nrxeLx9+/bNmTOH6wABAAC4oUT/3wEAFMMwjx8/FovFsgbzVFRUeDze+vXrv/vuO4FA0Mjhye/JkycXLlw4c+bMvXv3+Hw+IYTWiCbiKioqdnZ2bm5uHEcJAADAHYyLAygFhmESEhJu3Lhx8+bN8PDw9+/fa2tr5+bmVl2Tz+cPHDgwMDDQ3Ny88eOUU0xMzBdffJGZmamqqlpaWlp1BR6Pp6WllZiY2LFjx8YPDwAAQElgXByAS8nJydeuXYuMjLxx40ZaWpqmpubgwYO/++47e3v7/v37d+vWLSUlRbqydDjcy8uLDjMrLR0dnby8PEJItYk4IYRhmIMHDyIRBwCAFg7j4gCNLTk5OTIyMioq6vLly69fv9bQ0LC2tra3tx86dKiVlVXFBxR6eHgcOnSIzujg8/mWlpaBgYFmZmbcxV4L+/fv9/DwqPYKo6Ki4uzsfOTIkcaPCgAAQKkgFwdoDG/fvo2Kirp27VpoaGhKSoq6uvqQIUOGDh1qY2MzbNgwVVXVarc6ceLE1KlT+Xy+ioqKr6+vh4dH03ral7Oz85kzZ8RiccWFfD6/ffv2iYmJOjo6XAUGAACgJJCLAzSU9PT0iIiIa9euXbt2LTk5WU1NbcCAATY2Nvb29ra2tq1ataqxhIyMjE6dOtna2v7+++/K89wxqyilsgAAIABJREFU+d27d2/MmDF5eXkVb0Ll8XjXrl0bOXIkh4EBAAAoCcwXB1CkjIyMW7du0SkosbGxQqGwb9++jo6O9vb2NjY2tX00bIcOHV6+fGlkZNS0hsOpffv2eXp69ujR4/Hjx9KFQqFwwYIFSMQBAAAojIsD1FdWVlZMTAydgnL//n2BQNC3b197e3s6BVxNTY3rABtbVlbWnDlzzp8/v3Dhwu3bt2/btm3t2rXl5eVCodDExCQuLq4FtgkAAEC1kIsD1MXHjx/v3LlD55/cv3+fz+f369ePJt/Dhg3T0tLiOkDOXLt2bebMmUKhMDAw0M7OjhAikUiGDx9++/ZtHo93586dTz/9lOsYAQAAlAVycQB5iUSimJgYmn8/ePCAx+OZm5vT+d8ODg7a2tpcB8ix4uLitWvXbt++/auvvtq3b5+urq70qzdv3vTp08fT03PVqlUcRggAAKBskIsDsCkoKIiOjqaPAL97925ZWZmpqan9P/AkEKknT55Mmzbt5cuX27dvd3d3r7pCSUmJPLerAgAAtCjIxQEqo/k3vf/y1q1bpaWl0vx75MiRenp6XAeoXBiGOXDgwNKlS/v06XPkyJHu3btzHREAAECTgVwcgBBCCgsL79+/T++/rJh/Dx06dNSoUZ06deI6QCWVkZExe/bs0NDQVatWrVmzRiAQcB0RAABAU4JcHFousVj86NEjOv87IiKipKTE1NSUvn9n7NixnTt35jpAZXf27Nk5c+ZoamoGBQUNHTqU63AAAACaHuTi0LJUzL8jIyOLi4sNDAzo/ZefffZZly5duA6waRCJREuXLj148KCrq6ufn5+mpibXEQEAADRJyMWh+ZNIJA8fPqTJ961bt/Lz86X5t4ODQ9euXbkOsImJioqaOXNmbm7u/v37v/rqK67DAQAAaMKQi0PzRPNvev9laGhoXl5ex44dbW1t6RRwCwsLrgNsksrKyjZt2rRx40Z7e/vffvsN0+gBAADqCbk4NB/l5eWJiYn0/str167l5OTo6+vb2dnRKeADBgxoim+SVx5PnjyZMWNGUlLS5s2bFy1ahMYEAACoP+Ti0OQlJyfT5DssLOzDhw/t27e3srKiU1CQfytEeXn5rl27vL29+/fvHxgYaGZmxnVEAAAAzQRycWiSpPn39evXs7Oz27RpY2VlRR8BjvxbsVJSUr755pvbt2+vXLkSTy0EAABQLOTi0GTQ/DsyMvLGjRtpaWmampqDBw+m+Xf//v35fD7XATZDgYGB3377bZcuXY4cOdK/f3+uwwEAAGhukIuDUktOTqb3X16+fPn169caGhrW1tb0/ksrKysVFRWuA2y2MjIy3N3dL1y4sGDBgh9//BGvrwcAAGgItcjFPT0909LSGjQaAKmsrKw7d+4UFRUJhcJ27dq1b99eX19fR0dH1vwTgUCwZcsWExOTxg2zeTp16tS8efM0NTUPHz48bNgwrsMBAABotmqRi/N4vMGDB+NlhNA4ioqKUlJSaP4tz/yTkydPnjhxwsnJqRFia8by8vKWL1++f//+GTNm/PLLL3iJDwAAQIMS1mrtpUuXItcB5YT7Nevv8uXLc+bMkUgkFy9eHDt2LNfhAAAANH+43Q0ASF5enpub2+eff25jY/P48WMk4gAAAI2jduPiAND8XLlyZc6cOSUlJSdPnpw8eTLX4QAAALQgGBcHaLny8vLmzp07duzYwYMHP3nyBIk4AABAI8O4OEALdfnyZXd399LSUgyHAwAAcAXj4gAtDh0O//zzzwcPHhwfH49EHAAAgCsYFwdoWejDUsrKyk6dOvXVV19xHQ4AAECLhnFxgJZCOjvc2to6Pj4eiTgAAADnMC4O0CJcunTJ3d29rKzszJkzX375JdfhAAAAACEYFwdo9nJzc+nscGtr6ydPniARBwAAUB4YFwdozs6dOzdv3jwej3f+/PkJEyZwHQ4AAAD8D4yLAzRP7969c3R0nDRp0ujRo+Pj45GIAwAAKCGMiwM0NwzDHDlyxNPTs23btpcvX/7ss8+4jggAAACqh3FxgGblxYsXo0ePnjVr1uTJk+Pi4pCIAwAAKDPk4gDNhFgs3rlzZ9++fTMzM6Ojo/ft26epqcl1UAAAAMBG6XLx0tLSyMjIxtlXRkZGcHDwpk2bGmd3VeXm5nK1a2hmHj58OHjw4BUrVnz33Xf37t2ztLTkOiIAAACoWaPm4lZWVl5eXrK+/fDhw4oVK3R0dGxtbRshmMTExPXr1zs7Ox85cqS227JXpEbFxcWbNm2ytrbW09OrcyERERE+Pj48Ho/H47m4uJw7d67ORcnpxo0bjo6OdI9z586Niopq6D2CPAoLC318fAYOHKiurn7//v21a9eqqqpyHRQAAADIhccwjLyr8ngnTpxwcnKq886+/vprMzOzDRs2yFqBYZgOHTpkZWXJH1V9FBcXq6mpmZubP336lH3N1NTUzp07Sz9Wqkilb+VRVFTUqVOnnJyceta0S5cur1+/LigoUFdXr085LCrWrrCwUENDw9jY+NWrVw20uzqr//HZFN28edPd3T0rK2vbtm1z5szh8XhcRwQAAAC10Kjj4sePH2dJxAkhPB5PV1e30eJp3bq1PKu9fPly6tSpFZdUrEjVb+Whpqamr69f262qLYcQ0nCJeKXa0R3RnQK3cnJy5s6dO3LkSHNz8/j4eHd3dyTiAAAATQ6eaViDtLS08ePHSySSOnzb1DXv2jVpJ0+e/Pbbb4VC4cmTJydPnsx1OAAAAFBHChsXZxgmOjp62bJlJiYm6enpkydP1tXV7dWr1+nTpwkhEokkODh45syZw4YNo+uLRKINGzZMnz590aJFdnZ2fn5+VWdr/PTTT61atVq2bFlkZOT+/fvpTGVCSH5+vq+vL/3Ivt9aefbs2ZQpU7y9vWfMmGFraxsXF0cICQgISEhISE9P9/DwqFqRSt/KCpKWX1hY6Onp6e7uvnr16hUrVhQUFEh3XVRUtG3bNldX14EDB9rb2z9+/Jguv379upGRUXh4uDztf+7cOXd3dyMjo5ycnJkzZ+rp6fXq1euvv/5ibyKWmCvVrs5tGBQUpK6uzuPxtm7dKhaLCSFHjx5VVVUNCAiotu4SieTmzZtLliwxMTF58+aNnZ2dsbFxTk6OnDE0by9fvhwzZszXX3/t5OT09OlTJOIAAABNGyM3QsiJEydkfSsWi0NCQuisjwULFoSHhx89epQ+Ui0yMpJhGDrD2NzcnGGY0tJSOzu76dOnSyQShmEOHTpECDl//jzDMObm5jSq7Ozs6dOnP3r0SLoLU1PTigHTjzXut8ZK0ZAYhunevbupqSkNT0tLy8LCouo6lSpS9dtqg2QYpqyszNLS0s3Nrby8nGGYv//+WyAQSNd0c3NLTEyk/3ZwcNDX18/Ly2MY5uzZs2pqarRlqiVtrvLy8tTUVA0NDULIxo0bU1JS6D2plpaWNTaRrJir1q7aJRXJasNVq1YRQuLj46VtOGnSJFl1z8zMjIqKojNhNm/efPXqVVdX148fP8raqTQwluOzGSgpKdm0aZO6uvonn3wSFRXFdTgAAACgAArLxSkzMzNCiEgkoh937NhBCHF2dmYYpry8XJrG+fr6EkKePn1KVysrKzt06NCHDx+Yf5LLFy9ezJ49OzMzs2Lh0ryz6keW/dZYKWlm6evre+zYMYZhJBKJqampUCisuk6lilT9VlaQu3btIoQkJCRUaiuGYWJiYqr+RgoJCZE2Dkv8lXbXo0cP6cfy8nJ9fX1VVdUam4ilYWubi8tqw/fv32tqarq5udGPmzdvphVkqTutS3Z2Nkv1/6+9e4+qqkwfOP5yGQxQFLyCmkopLPFSmVSOhpS4KsRxLZMYREwFTIbLDKYgkoWISHkPli5nMFCUJGvpMMoKJbVUWKZOmaGoeAMvoFw9ILdz9u+P/ev8+IEcEThuhO/nL8/em/0+z3twree8PPs9jQLrxLX40aNHR44caWpq+umnn1ZXVysdDgAAaB/t/OymoaGhEEJenRVCTJ8+XQhx+fJlIUTDB8uOHj0qhBg0aJD80tjYeN68eZaWltoLXF1dKysr+/Tp0/ZxWy4kJMTNzS0+Pj46OrqmpkbupmiqdU/IZWRkCCGGDh3aKGYhxM8//6xdP9aaNm2afNbY+Al6+hvGZmBgYGlpWVtb23C4Nk7RYzU3h7179w4MDExKSrp165YkSZmZme+8847Qmbucy9N8lrdjunv3rre3t7Ozs62tbU5OzmeffdatWzelgwIAAO1Dv/uo2NjYCCGa7vdXWFgodBaCa9eu3bNnT2xsbPuOq9upU6dGjx5ta2v7ySeftPsXFt66dUsIUVxc3PRUcXHx1atXG7aPCyH0/cRk66ZIh6Kiorq6Oh1zGBISYmJisnHjxjNnzjg6OsqfMRTJ/Vmh0Wi2bdtmZ2d35MiR1NTUtLS0hp/lAABAJ6DfWlwuPadMmdLo+NixY4UQ0dHRcr+HEOL69esHDx7UXuDq6hoeHh4eHt7woLxQWlNTI4TQaDTl5eVCCOlR+3M3N65u3t7edXV17777rnz/hjdvbo286dnmgrS3txdCHDhwoOmP29vby88vao/k5OTExcW1ZOhWazhFuie2JQFIkuTv729kZKRjDvv06bNo0aKtW7du3rx5/vz58kHduXdlZ86cef311wMCAj788MMLFy68//77SkcEAAD0oOXtLKIF/bhyq7G2xTkxMfGVV16pra2VJKmiokIIYW1tLUlSXl6evFO1s7NzXFxcRESEn5+f/BynvPKnVqvr6uqcnZ179ux59uxZ+W4zZswQQkRERFy6dGn9+vVyT0t6enp9fb2OcXWQl2OHDBkiv7SwsBBCfP/998nJyX379hVCZGdn37x584UXXjAzM7tx44Z8WcNEJElqdLa5IE+fPm1kZGRlZZWenl5ZWZmZmdmjRw8hxNWrVx8+fDhs2DAhxLx585KTk5cvX+7i4iI/u5mWlmZubn7w4MHmUpAXtrVd4EOGDBFCyI+HSpIkL37L86BjinRMbKPs5NV9Gxsb+c2SlZWV+fr6zp49W8ccylfeuXPHxMTEyclJ+7M6cpdzeewjm1ot+f18JpSUlAQFBRkaGk6ePPn3339XOhwAAKBHeqnFv/jii3v37hUWFsbExMi1lEqlCgsLk6v/devWlZeXnzt3burUqb169bKxsQkODi4rKysuLl65cqV8TXR0dEFBQVJSkhCiR48eq1evLi0tzc3NdXR0NDMzc3Fxyc3NnThxopeXV0pKSnV1dXPj6pCXlxcYGCgPt2HDhpKSkri4OAsLi/Hjx2dlZW3cuLFXr17Tp0+/f/9+WFjYgAED9u7d+8hEGp6VJElHkMeOHZswYUL37t2HDRsWExMzadKkhQsXHj58uL6+/tq1a25ubpaWlv379/f19dU+tJqRkWFtbZ2Zmdk0/h9//DE0NFSOxNPTc9++fdrl5KioqLKyMvnpTCFEaGhoVVWVjinSEXPD7DIzM+UucyGEnZ3d5MmTJ0+ePGLECPkb1xMTEyVJam4OtWG7urru2LGjYSJNc1epVJGRkfJAvr6+2g9junWCWlyj0SQlJfXt29fa2jopKUn7mQoAAHRWBlKLv4O9Jd8xbm9vn5ub2/J7thelxn2GdIQpqqysHDt27Llz5/TxRaEt+f3syH799Vd/f/9Tp075+/tHRUXJf2EAAACdm377xRVn0LyLFy8qHV2XEx8fHxgYqI9C/JlWWVkZFhb26quv1tTUnDx5ctOmTRTiAAB0EU+wX15LyB3YKpWq3fchad24rJRrKfXWCCGys7P9/PyqqqrUajUfgRpJSUlZvHhxXV3d1q1b58+f37odMwEAwDOq3dbFVSpVeHh4QUGBECIoKCgrK6u97twxx32GKD5F5ubmFRUVhoaGu3fvZm9srf/+979OTk6zZ8+eMmVKTk7OggULKMQBAOhq2rlfHFDKM/T7WVRUFBERkZCQ4OjouGnTJkdHR6UjAgAAyujk/eJAh1JXV7dp06YRI0YcOHBgy5YtJ06coBAHAKAra+d+cQDNOXz4cHBw8LVr14KCgpYvXy5vMA8AALoy1sUBvcvNzXV1dXVxcbG1tf3999/XrFlDIQ4AAAS1OKBXpaWlYWFhY8aMuXPnzrFjx9LS0uTvGQUAABD0qAB6Ul9fv3379oiICI1G8/nnnwcEBBgZGSkdFAAA6FhYFwfa3w8//DBu3LiAgIC//vWveXl5wcHBFOIAAKApanGgPV25csXd3f3tt9/u16/fL7/8smnTpp49eyodFAAA6KCoxYH2UV5evnTpUgcHh5ycnIyMjEOHDo0cOVLpoAAAQIdGvzjQVrW1tVu2bFm1apUkSevXr1+4cKGxMf+zAADA47EuDrSeJEnffPONg4PD0qVLPT09r1y58re//Y1CHAAAtBBFA9BKWVlZS5YsycrKmjlzZkZGBpsVAgCAJ8W6OPDELl686O7uPmHCBFNT09OnT6emplKIAwCAVqAWB55Afn6+j4/PqFGjrly5cujQoUOHDr388stKBwUAAJ5VT9ajsmHDhr179+opFKAju3fvXkxMzJYtWwYMGJCYmOjp6WloyEdZAADQJk9Qi//jH/8oKCjQXyhAW3h4eDg6OurjziqVKj4+PiYm5k9/+tNnn30WHBz83HPP6WMgAADQ1RhIkqR0DEAHVVtbm5iYuGLFiqqqKn9///DwcAsLC6WDAgAAnQf7qACPUF9fn5iYGBkZWVJSEhgYGBoaamlpqXRQAACgs6HhFfh/NBqNvGW4v7//e++9d/ny5TVr1lCIAwAAfWBdHPhfarU6JSUlKirq6tWrc+bMSU9Pt7W1VTooAADQmVGLA0Kj0Xz77bcrVqy4dOnSzJkz09LSRowYoXRQAACg86NHBV2aRqNJS0sbN26ch4fH6NGjc3JyUlNTKcQBAMDTQS2OLkqtVu/evXvMmDEzZsxwcHCQq3A7Ozul4wIAAF0ItTi6nNra2oSEBHt7e29v75deeun8+fPJyclU4QAA4OmjXxxdSE1NTVJS0qpVq+7evevh4fGf//yHEhwAACiIWhxdgkqlSkhI+Pzzz4uLi+fOnRsRETF48GClgwIAAF0dtTg6ucLCwvj4+Pj4+Lq6ukWLFoWEhPTv31/poAAAAIQQwkCSJKVjAPQiJydnw4YNycnJ3bt3DwgICAwMtLKyUjooAACA/0Mtjk7o+PHjsbGxBw4csLW1DQwM9PX1NTMzUzooAACAxthHBZ1HbW3tzp07X3755UmTJj148GD//v2XLl0KDg6mEAcAAB0T/eLoDO7cubNjx464uLjbt2+/9957W7Zsef3115UOCgAA4DGoxfEMkyTp6NGj8fHx+/fvt7Ky8vHx+eijj9ggBQAAPCvoF8cz6cGDBykpKXFxcb/99tu4ceP8/PzmzJljamqqdFwAAABPgHVxPGNOnz6dkJCwa9cutVrt6em5Y8eOl156SemgAAAAWoN1cTwbSktLd+3alZCQ8Msvv4wcOdLX1/fDDz/s1auX0nEBAAC0HrU4OrozZ85s27ZNXgh3c3Pz8/N7++23DQwMlI4LAACgrajF0UHl5+cnJyd/9dVXly9fHj9+vI+Pj4eHh4WFhdJxAQAAtBv6xdGxqFSq7777bseOHUeOHLG0tPT09Ny7d++YMWOUjgsAAKD9UYujQ9BoNCdPnty5c2dKSkpVVZWzs/PXX3/9l7/8xcTEROnQAAAA9OURPSrV1dUHDx5Uq9WKBIQu6MSJE8nJycXFxS+++OKbb7755z//uUePHu118/Hjxw8dOrS97gYAANCOHlGLf/fddzNnzlQkGqDdeXh4pKSkKB0FAADAIzyiR6W+vl4IwTOd6ATc3d35Cw8AAOiwDJUOAAAAAOiiqMUBAAAAZVCLAwAAAMqgFgcAAACUQS0OAAAAKINaHAAAAFAGtTgAAACgDGpxAAAAQBnU4gAAAIAyqMUBAAAAZVCLAwAAAMqgFgcAAACUQS0OAAAAKINaHAAAAFCGkrV4bW3t8ePHn85YhYWFqamp0dHRT2e4tigrK1M6BAAAADwN+qrFX3vttSVLljR3tqSkZNmyZZaWlpMmTdJTAA1duHBh5cqVH3zwwc6dO/U3iu6UH6u6ujo6OvqNN97o3bt3q2/y008/hYWFGRgYGBgYeHt779+/v9W3aqEjR47MmjVLHnHhwoUnTpzQ94gAAACdhoEkSY0OpaamfvDBB02PPxEPD4/hw4dHRUU1d4EkSf379793714bB2qh6upqU1NTOzu7ixcv6mmIRinn5+cPHjz4ie7w8OHDgQMHlpaWtnFOhgwZcvPmzcrKSjMzs7bcR4eG2VVVVZmbmz///PM3btzQ03Ct5u7uLoRITU1VOhAAAIBHMNbTfb/++mvdFxgYGFhZWd27d09PATTy3HPP6XuIhilfu3bN29v7p59+eqI7mJqa9uvXr7S0tI2RmJqaCiH0V4g3yk4eSB4UAAAALaevWrwrKygomDZtmlqtVjoQvejc2QEAADxNrekXlyQpKytr8eLFQ4cOvXv37syZM62srEaNGvXtt98KIdRqdWpq6ty5c9988035epVKFRUV5eXlFRQU5OTktHHjxqY9GGvXru3WrdvixYuPHz++bds2uf9YCFFRUbFu3Tr5pe5xn0h5efnSpUvDwsJCQkKmTp0aEhIid4bs37/fz89v0KBBpaWlc+fO7d2796hRo06fPq1N/Msvv/Ty8lq0aFG3bt0M/tAo5cTExJycnLt373700UdCiObSke9ZVVUVEhLi5+cXERGxbNmyyspKbZAPHz6MjY1dsGDBq6++OmXKlN9++00+/sMPPwwaNOjYsWMteaeay0j3ZOqIuVF2LXHp0qX3338/NDR0zpw5kyZNOnfunBAiOTnZzMzMwMBgzZo19fX1Qohdu3aZmJgkJiY+Mne1Wn306NG///3vQ4cOvXXrlpOT0/PPP9/2vyEAAAAoSWpiz549jzyuVV9fn5aWJnd9BAQEHDt2bNeuXd27dxdCHD9+XJIkuW/Yzs5OkqTa2lonJycvLy+1Wi1J0vbt24UQ//73vyVJsrOzkwcqLi728vL69ddftUPY2to2jEF++dhxddOGVFFRMXz48E8//VQ+XlhYOHz48GHDhpWUlOTn55ubmwshVq1adf36dflZT0dHR/nKzZs3Gxoa3r9/X5Kk1atXCyFCQkLkUw1TbjiWjnQkSaqrq3N0dPTx8dFoNJIkXblyxcjISHulj4/PhQsX5H+7uLj069evvLxckqR9+/aZmprKc/hI2onVaDTNZfTYyWwu5qbZPfJIQy+++KKtra0kSbW1tT179nRwcJCPL1++XAhx/vx57RzOmDGjudyLiopOnDghd8KsXr360KFDCxYsePDgQXODymbNmjVr1izd1wAAACilNbW4bPjw4UIIlUolv9ywYYMQQn7oU6PRaIuzdevWCSEuXrwoX1ZXV7d9+/aSkhLpj5IxLy9v/vz5RUVFDW+urSabvtQx7mNS/SOk8PBwIcTt27e1p5KSkoQQS5YskSRpxIgR2rE0Gk2/fv1MTEzkl25ubgYGBjU1NZIkyavUr732mvZKHbV4c+l8+eWXQoicnJxGsypJUnZ2dtMPTmlpadpp1JFpo+F0ZKRjMnW8BU9ai69bt2737t2SJKnValtbW2NjY/n4/fv3u3fv7uPjI79cvXq1nKCO3OVciouLdaTfELU4AADoyFq/p6GhoaEQQl5zFUJMnz5dCHH58mUhhLYBQwhx9OhRIcSgQYPkl8bGxvPmzbO0tNRe4OrqWllZ2adPn7aP20Lyvns9evTQHpF7S06ePNkoeAMDA0tLy9raWvmli4uLJEkHDhwQfzwM+tZbb2mvbHkAWhkZGUKIoUOHao/I2Qkhfv75Z+36sda0adPks8bGT9DoryOjtk9mS4SEhLi5ucXHx0dHR9fU1MgdKUKI3r17BwYGJiUl3bp1S5KkzMzMd955R+jMXc7FysqqfSMEAABQRLvtL25jYyOEaLqLX2FhodBZ3q1du3bPnj2xsbHtO64OcgF6/fp17ZH+/fsLIXr27Kn7BwMCAv75z38uWLDg448/Xrx4cWRk5MqVK1sRs9atW7eEEMXFxU1PFRcXX716tWH7uBBC309MtmIydSsqKqqrqzt16tTo0aNtbW0/+eQTuQ1GKyQkxMTEZOPGjWfOnHF0dJQ/YyiSOwAAwNPXbrW4XFBOmTKl0fGxY8cKIaKjo+UuDiHE9evXDx48qL3A1dU1PDw8PDy84UF5+bOmpkYIodFoysvLhRDSo3bdbm5cHeRVcHl5W5afn9+Sm6jV6vPnz2dnZ69du3b//v0rVqzQsT6tXf3VkY69vX2jSLTs7e3l5xe1R3JycuLi4prevB01nEzdb0FLApAkyd/f38jIyNvbu66u7t1335Vv1fA+ffr0WbRo0datWzdv3jx//nz5oO7cAQAAOo+mbSst7BeXG4i1jcuJiYmvvPJKbW2tJEkVFRVCCGtra0mS8vLy5P2nnZ2d4+LiIiIi/Pz85Oc45d4MtVpdV1fn7Ozcs2fPs2fPynebMWOGECIiIuLSpUvr16+Xe1rS09Pr6+t1jKuDvMg6ZMgQ+d8ODg4DBw7UtowHBQVNmDBBvsmQIUOEEPLDlJIkyUvF8qnIyEhbW9t//etf6enpJ06cyM3N1YbRMGVJkl544QUzM7MbN27oTuf06dNGRkZWVlbp6emVlZWZmZly58zVq1cfPnw4bNgwIcS8efOSk5OXL1/u4uIiP7uZlpZmbm5+8ODB5pKVF7a1XeA6MtIxmTregkbZyav7NjY28tsqKysr8/X1nT17tiRJFhYWQojvv/8+OTm5b9++Qojs7OybN2/KV965c8fExMTJyUn7szpyl3N57CObWvSLAwCAjqyttfgXX3xx7969wsK/AISXAAADcklEQVTCmJgYuUJSqVRhYWFyob9u3bry8vJz585NnTq1V69eNjY2wcHBZWVlxcXF2u6O6OjogoIC+enJHj16rF69urS0NDc319HR0czMzMXFJTc3d+LEiV5eXikpKdXV1c2Nq0NeXl5gYKA83IYNG0pKSioqKpYsWeLi4hISErJkyZLIyMjq6mpJkrSLr1FRUWVlZfKzjEKI0NDQqqqqjIyMfv36Nfwk06dPn7179zZNOSwsbMCAAXv37pUD0JHOsWPHJkyY0L1792HDhsXExEyaNGnhwoWHDx+ur6+/du2am5ubpaVl//79fX19tY+3ZmRkWFtbZ2ZmNs30xx9/DA0NlSPx9PTct2+f7ox0TKaOmBtml5mZKXeZCyHs7OwmT548efLkESNGmJiYCCESExPlWbWwsBg/fnxWVtbGjRt79eo1ffp0eTsamaur644dOxom0jR3lUoVGRkpD+Tr66v92KYbtTgAAOjIDKQmjR+pqanyTho619OFvb19bm7uYy9rd0qNK0nSV199df/+/aVLlwoh1Gr17du3jxw58vHHHxcVFT3lYNqLUpPZUGVl5dixY8+dO6ePLwp1d3cXQqSmprb7nQEAANqu83zvpo6dTC5cuCB3ZrdFbGzssmXL7t+/L780MjIaPHjwxIkTBw4c2MY7d3Hx8fGBgYH6KMQBAAA6uNbX4nIHtkqlarQzhr41N66+F3ePHz8uhNi6devChQvlHRjPnDkTGxubnJys13H1Sqk3UQiRnZ3t5+dXVVWlVqsvXrz4lEcHAADoCFqzj4pKpQoPDy8oKBBCBAUFZWVltXdUHWtcWVJSUkBAQEJCwqBBgyZMmDBr1qyzZ88mJyc7ODg8zTDai7KTKYQwNzevqKgwNDTcvXt3t27dnvLoAAAAHUHr+8WBjo9+cQAA0JG12/7iAAAAAJ4ItTgAAACgDGpxAAAAQBnU4gAAAIAyqMUBAAAAZVCLAwAAAMqgFgcAAACUQS0OAAAAKINaHAAAAFAGtTgAAACgDGpxAAAAQBnU4gAAAIAyqMUBAAAAZRg3d+Kbb755mnEA+pCfnz948GClowAAAHi0R9Ti1tbWxsbG7u7uTz8aoN298cYbSocAAADwaAaSJCkdAwAAANAV0S8OAAAAKINaHAAAAFAGtTgAAACgDGpxAAAAQBn/AzPY3WJRcf63AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = build_dnn_model()\n",
    "\n",
    "tf.keras.utils.plot_model(model, 'dnn_model.png', show_shapes=False, rankdir='LR')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the model\n",
    "\n",
    "To train the model, simply call [model.fit()](https://keras.io/models/model/#fit).  Note that we should really use many more NUM_TRAIN_EXAMPLES (i.e. a larger dataset). We shouldn't make assumptions about the quality of the model based on training/evaluating it on a small sample of the full data.\n",
    "\n",
    "We start by setting up the environment variables for training, creating the input pipeline datasets, and then train our baseline DNN model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAIN_BATCH_SIZE = 32 \n",
    "NUM_TRAIN_EXAMPLES = 59621 * 5\n",
    "NUM_EVALS = 5\n",
    "NUM_EVAL_EXAMPLES = 14906"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "1301/1863 [===================>..........] - ETA: 5s - loss: 101.3527 - rmse: 9.4333 - mse: 101.3527"
     ]
    }
   ],
   "source": [
    "trainds = load_dataset('../data/taxi-train*',\n",
    "                       TRAIN_BATCH_SIZE,\n",
    "                       'train')\n",
    "evalds = load_dataset('../data/taxi-valid*',\n",
    "                      1000,\n",
    "                      'eval').take(NUM_EVAL_EXAMPLES//1000)\n",
    "\n",
    "steps_per_epoch = NUM_TRAIN_EXAMPLES // (TRAIN_BATCH_SIZE * NUM_EVALS)\n",
    "\n",
    "history = model.fit(trainds,\n",
    "                    validation_data=evalds,\n",
    "                    epochs=NUM_EVALS,\n",
    "                    steps_per_epoch=steps_per_epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize the model loss curve\n",
    "\n",
    "Next, we will use matplotlib to draw the model's loss curves for training and validation.  A line plot is also created showing the mean squared error loss over the training epochs for both the train (blue) and test (orange) sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_curves(history, metrics):\n",
    "    nrows = 1\n",
    "    ncols = 2\n",
    "    fig = plt.figure(figsize=(10, 5))\n",
    "\n",
    "    for idx, key in enumerate(metrics):  \n",
    "        ax = fig.add_subplot(nrows, ncols, idx+1)\n",
    "        plt.plot(history.history[key])\n",
    "        plt.plot(history.history['val_{}'.format(key)])\n",
    "        plt.title('model {}'.format(key))\n",
    "        plt.ylabel(key)\n",
    "        plt.xlabel('epoch')\n",
    "        plt.legend(['train', 'validation'], loc='upper left');    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_curves(history, ['loss', 'mse'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict with the model locally\n",
    "\n",
    "To predict with Keras, you simply call [model.predict()](https://keras.io/models/model/#predict) and pass in the cab ride you want to predict the fare amount for.  Next we note the fare price at this geolocation and pickup_datetime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8.0715685]], dtype=float32)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict({\n",
    "    'pickup_longitude': tf.convert_to_tensor([-73.982683]),\n",
    "    'pickup_latitude': tf.convert_to_tensor([40.742104]),\n",
    "    'dropoff_longitude': tf.convert_to_tensor([-73.983766]),\n",
    "    'dropoff_latitude': tf.convert_to_tensor([40.755174]),\n",
    "    'passenger_count': tf.convert_to_tensor([3.0]),\n",
    "    'pickup_datetime': tf.convert_to_tensor(['2010-02-08 09:17:00 UTC'], dtype=tf.string),\n",
    "}, steps=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Improve Model Performance Using Feature Engineering \n",
    "\n",
    "We now improve our model's performance by creating the following feature engineering types:  Temporal, Categorical, and Geolocation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Temporal Feature Columns\n",
    "\n",
    "**Lab Task #1**: Processing temporal feature columns in Keras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We incorporate the temporal feature pickup_datetime.  As noted earlier, pickup_datetime is a string and we will need to handle this within the model.  First, you will include the pickup_datetime as a feature and then you will need to modify the model to handle our string feature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wed Jun 14 05:49:48 2023\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(1,), dtype=string, numpy=array([b'Tue'], dtype=object)>"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TODO 1a\n",
    "def parse_datetime(s):\n",
    "    if type(s) is not str:\n",
    "        s = s.numpy().decode('utf-8')\n",
    "    return datetime.strptime(s, \"%a %b %d %H:%M:%S %Y\")\n",
    "\n",
    "\n",
    "# TODO 1b\n",
    "def get_dayofweek(s):\n",
    "    ts = parse_datetime(s)\n",
    "    return DAYS[ts.weekday()]\n",
    "\n",
    "\n",
    "# TODO 1c\n",
    "@tf.function\n",
    "def dayofweek(ts_in):\n",
    "    return tf.map_fn(\n",
    "        lambda s: tf.py_function(get_dayofweek, inp=[s], Tout=tf.string),\n",
    "        ts_in)\n",
    "\n",
    "format = \"%a %b %d %H:%M:%S %Y\"\n",
    "\n",
    "today_str = datetime.now().strftime(format)\n",
    "print(today_str)\n",
    "\n",
    "dayofweek(tf.constant([today_str]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Geolocation/Coordinate Feature Columns\n",
    "\n",
    "The pick-up/drop-off longitude and latitude data are crucial to predicting the fare amount as fare amounts in NYC taxis are largely determined by the distance traveled. As such, we need to teach the model the Euclidean distance between the pick-up and drop-off points.\n",
    "\n",
    "Recall that latitude and longitude allows us to specify any location on Earth using a set of coordinates. In our training data set, we restricted our data points to only pickups and drop offs within NYC. New York city has an approximate longitude range of -74.05 to -73.75 and a latitude range of 40.63 to 40.85.\n",
    "\n",
    "#### Computing Euclidean distance\n",
    "The dataset contains information regarding the pickup and drop off coordinates. However, there is no information regarding the distance between the pickup and drop off points. Therefore, we create a new feature that calculates the distance between each pair of pickup and drop off points. We can do this using the Euclidean Distance, which is the straight-line distance between any two coordinate points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euclidean(params):\n",
    "    lon1, lat1, lon2, lat2 = params\n",
    "    londiff = lon2 - lon1\n",
    "    latdiff = lat2 - lat1\n",
    "    return tf.sqrt(londiff*londiff + latdiff*latdiff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scaling latitude and longitude\n",
    "\n",
    "It is very important for numerical variables to get scaled before they are \"fed\" into the neural network. Here we use min-max scaling (also called normalization) on the geolocation features.  Later in our model, you will see that these values are shifted and rescaled so that they end up ranging from 0 to 1.\n",
    "\n",
    "First, we create a function named 'scale_longitude', where we pass in all the longitudinal values and add 78 to each value.  Note that our scaling longitude ranges from -70 to -78. Thus, the value 78 is the maximum longitudinal value.  The delta or difference between -70 and -78 is 8.  We add 78 to each longitudinal value and then divide by 8 to return a scaled value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_longitude(lon_column):\n",
    "    return (lon_column + 78)/8."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we create a function named 'scale_latitude', where we pass in all the latitudinal values and subtract 37 from each value.  Note that our scaling latitude ranges from -37 to -45. Thus, the value 37 is the minimal latitudinal value.  The delta or difference between -37 and -45 is 8.  We subtract 37 from each latitudinal value and then divide by 8 to return a scaled value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_latitude(lat_column):\n",
    "    return (lat_column - 37)/8."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Putting it all together\n",
    "We will create a function called \"euclidean\" to initialize our geolocation parameters. We then create a function called transform. The transform function passes our numerical and string column features as inputs to the model, scales geolocation features, then creates the Euclidean distance as a transformed variable with the geolocation features. Lastly, we bucketize the latitude and longitude features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lab Task #2:** We will use Lambda layers to create two new \"geo\" functions for our model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lab Task #3:** Creating the bucketized and crossed feature columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transform(inputs, numeric_cols, string_cols, nbuckets):\n",
    "    print(\"Inputs before features transformation: {}\".format(inputs.keys()))\n",
    "\n",
    "    # Pass-through columns\n",
    "    transformed = inputs.copy()\n",
    "    del transformed['pickup_datetime']\n",
    "\n",
    "    feature_columns = {\n",
    "        colname: tf.feature_column.numeric_column(colname)\n",
    "        for colname in numeric_cols\n",
    "    }\n",
    "\n",
    "    # TODO 2a\n",
    "    # Scaling longitude from range [-70, -78] to [0, 1]\n",
    "    for lon_col in ['pickup_longitude', 'dropoff_longitude']:\n",
    "        transformed[lon_col] = layers.Lambda(\n",
    "            scale_longitude,\n",
    "            name=\"scale_{}\".format(lon_col))(inputs[lon_col])\n",
    "\n",
    "    # TODO 2b\n",
    "    # Scaling latitude from range [37, 45] to [0, 1]\n",
    "    for lat_col in ['pickup_latitude', 'dropoff_latitude']:\n",
    "        transformed[lat_col] = layers.Lambda(\n",
    "            scale_latitude,\n",
    "            name='scale_{}'.format(lat_col))(inputs[lat_col])\n",
    "\n",
    "    # add Euclidean distance\n",
    "    transformed['euclidean'] = layers.Lambda(\n",
    "        euclidean,\n",
    "        name='euclidean')([inputs['pickup_longitude'],\n",
    "                           inputs['pickup_latitude'],\n",
    "                           inputs['dropoff_longitude'],\n",
    "                           inputs['dropoff_latitude']])\n",
    "    feature_columns['euclidean'] = fc.numeric_column('euclidean')\n",
    "\n",
    "    # TODO 3a\n",
    "    # create bucketized features\n",
    "    latbuckets = np.linspace(0, 1, nbuckets).tolist()\n",
    "    lonbuckets = np.linspace(0, 1, nbuckets).tolist()\n",
    "    b_plat = fc.bucketized_column(\n",
    "        feature_columns['pickup_latitude'], latbuckets)\n",
    "    b_dlat = fc.bucketized_column(\n",
    "        feature_columns['dropoff_latitude'], latbuckets)\n",
    "    b_plon = fc.bucketized_column(\n",
    "        feature_columns['pickup_longitude'], lonbuckets)\n",
    "    b_dlon = fc.bucketized_column(\n",
    "        feature_columns['dropoff_longitude'], lonbuckets)\n",
    "\n",
    "    # TODO 3b\n",
    "    # create crossed columns\n",
    "    ploc = fc.crossed_column([b_plat, b_plon], nbuckets * nbuckets)\n",
    "    dloc = fc.crossed_column([b_dlat, b_dlon], nbuckets * nbuckets)\n",
    "    pd_pair = fc.crossed_column([ploc, dloc], nbuckets ** 4)\n",
    "\n",
    "    # create embedding columns\n",
    "    feature_columns['pickup_and_dropoff'] = fc.embedding_column(pd_pair, 100)\n",
    "\n",
    "    print(\"Transformed features: {}\".format(transformed.keys()))\n",
    "    print(\"Feature columns: {}\".format(feature_columns.keys()))\n",
    "    return transformed, feature_columns\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll create our DNN model now with the engineered features. We'll set `NBUCKETS = 10` to specify 10 buckets when bucketizing the latitude and longitude."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "NBUCKETS = 10\n",
    "\n",
    "\n",
    "# DNN MODEL\n",
    "def rmse(y_true, y_pred):\n",
    "    return tf.sqrt(tf.reduce_mean(tf.square(y_pred - y_true)))\n",
    "\n",
    "\n",
    "def build_dnn_model():\n",
    "    # input layer is all float except for pickup_datetime which is a string\n",
    "    inputs = {\n",
    "        colname: layers.Input(name=colname, shape=(), dtype='float32')\n",
    "        for colname in NUMERIC_COLS\n",
    "    }\n",
    "    inputs.update({\n",
    "        colname: tf.keras.layers.Input(name=colname, shape=(), dtype='string')\n",
    "        for colname in STRING_COLS\n",
    "    })\n",
    "\n",
    "    # transforms\n",
    "    transformed, feature_columns = transform(inputs,\n",
    "                                             numeric_cols=NUMERIC_COLS,\n",
    "                                             string_cols=STRING_COLS,\n",
    "                                             nbuckets=NBUCKETS)\n",
    "    dnn_inputs = layers.DenseFeatures(feature_columns.values())(transformed)\n",
    "\n",
    "    # two hidden layers of [32, 8] just in like the BQML DNN\n",
    "    h1 = layers.Dense(32, activation='relu', name='h1')(dnn_inputs)\n",
    "    h2 = layers.Dense(8, activation='relu', name='h2')(h1)\n",
    "\n",
    "    # final output is a linear activation because this is regression\n",
    "    output = layers.Dense(1, activation='linear', name='fare')(h2)\n",
    "    model = models.Model(inputs, output)\n",
    "\n",
    "    # Compile model\n",
    "    model.compile(optimizer='adam', loss='mse', metrics=[rmse, 'mse'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inputs before features transformation: dict_keys(['pickup_longitude', 'pickup_latitude', 'dropoff_longitude', 'dropoff_latitude', 'passenger_count', 'pickup_datetime'])\n",
      "Transformed features: dict_keys(['pickup_longitude', 'pickup_latitude', 'dropoff_longitude', 'dropoff_latitude', 'passenger_count', 'euclidean'])\n",
      "Feature columns: dict_keys(['pickup_longitude', 'pickup_latitude', 'dropoff_longitude', 'dropoff_latitude', 'passenger_count', 'euclidean', 'pickup_and_dropoff'])\n"
     ]
    }
   ],
   "source": [
    "model = build_dnn_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how our model architecture has changed now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) ', 'for plot_model/model_to_dot to work.')\n"
     ]
    }
   ],
   "source": [
    "tf.keras.utils.plot_model(model, 'dnn_model_engineered.png', show_shapes=False, rankdir='LR')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainds = load_dataset('../data/taxi-train*',\n",
    "                       TRAIN_BATCH_SIZE,\n",
    "                       'train')\n",
    "evalds = load_dataset('../data/taxi-valid*',\n",
    "                      1000,\n",
    "                      'eval').take(NUM_EVAL_EXAMPLES//1000)\n",
    "\n",
    "steps_per_epoch = NUM_TRAIN_EXAMPLES // (TRAIN_BATCH_SIZE * NUM_EVALS)\n",
    "\n",
    "history = model.fit(trainds,\n",
    "                    validation_data=evalds,\n",
    "                    epochs=NUM_EVALS+3,\n",
    "                    steps_per_epoch=steps_per_epoch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As before, let's visualize the DNN model layers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_curves(history, ['loss', 'mse'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's a prediction with this new model with engineered features on the example we had above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[7.0562654]], dtype=float32)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict({\n",
    "    'pickup_longitude': tf.convert_to_tensor([-73.982683]),\n",
    "    'pickup_latitude': tf.convert_to_tensor([40.742104]),\n",
    "    'dropoff_longitude': tf.convert_to_tensor([-73.983766]),\n",
    "    'dropoff_latitude': tf.convert_to_tensor([40.755174]),\n",
    "    'passenger_count': tf.convert_to_tensor([3.0]),\n",
    "    'pickup_datetime': tf.convert_to_tensor(['2010-02-08 09:17:00 UTC'], dtype=tf.string),\n",
    "}, steps=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we summarize our training results comparing our baseline model with our model with engineered features."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Model              | Taxi Fare | Description                               |\n",
    "|--------------------|-----------|-------------------------------------------|\n",
    "| Baseline           | value?     | Baseline model - no feature engineering |\n",
    "| Feature Engineered | value?      | Feature Engineered Model                |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright 2021 Google Inc.\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at\n",
    "http://www.apache.org/licenses/LICENSE-2.0\n",
    "Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License."
   ]
  }
 ],
 "metadata": {
  "environment": {
   "kernel": "python3",
   "name": "tf2-gpu.2-6.m108",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/tf2-gpu.2-6:m108"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}