01_neural_network_regression_in_tensorflow.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "T4",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Pratik94229/Learning-Tensorflow/blob/main/01_neural_network_regression_in_tensorflow.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UPgo18-N1gSi"
      },
      "source": [
        "# 01. Neural Network Regression with TensorFlow\n",
        "\n",
        "There are many definitions for a [regression problem](https://en.wikipedia.org/wiki/Regression_analysis) but in our case, we're going to simplify it to be: predicting a number.\n",
        "\n",
        "For example, you might want to:\n",
        "- Predict the selling price of houses given information about them (such as number of rooms, size, number of bathrooms).\n",
        "- Predict the coordinates of a bounding box of an item in an image.\n",
        "- Predict the cost of medical insurance for an individual given their demographics (age, sex, gender, race).\n",
        "\n",
        "In this notebook, we're going to set the foundations for how you can take a sample of inputs (this is your data), build a neural network to discover patterns in those inputs and then make a prediction (in the form of a number) based on those inputs.\n",
        "\n",
        "## What we're going to cover\n",
        "\n",
        "Specifically, we're going to go through doing the following with TensorFlow:\n",
        "- Architecture of a regression model\n",
        "- Input shapes and output shapes\n",
        "  - `X`: features/data (inputs)\n",
        "  - `y`: labels (outputs)\n",
        "- Creating custom data to view and fit\n",
        "- Steps in modelling\n",
        "  - Creating a model\n",
        "  - Compiling a model\n",
        "    - Defining a loss function\n",
        "    - Setting up an optimizer\n",
        "    - Creating evaluation metrics\n",
        "  - Fitting a model (getting it to find patterns in our data)\n",
        "- Evaluating a model\n",
        "  - Visualizng the model (\"visualize, visualize, visualize\")\n",
        "  - Looking at training curves\n",
        "  - Compare predictions to ground truth (using our evaluation metrics)\n",
        "- Saving a model (so we can use it later)\n",
        "- Loading a model\n",
        "\n",
        "Don't worry if none of these make sense now, we're going to go through each.\n",
        "\n",
        "## How you can use this notebook\n",
        "\n",
        "You can read through the descriptions and the code (it should all run), but there's a better option.\n",
        "\n",
        "Write all of the code yourself.\n",
        "\n",
        "Yes. I'm serious. Create a new notebook, and rewrite each line by yourself. Investigate it, see if you can break it, why does it break?\n",
        "\n",
        "You don't have to write the text descriptions but writing the code yourself is a great way to get hands-on experience.\n",
        "\n",
        "Don't worry if you make mistakes, we all do. The way to get better and make less mistakes is to **write more code**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "etAu7oCZ8r_G"
      },
      "source": [
        "## Typical architecture of a regresison neural network\n",
        "\n",
        "The word *typical* is on purpose.\n",
        "\n",
        "Why?\n",
        "\n",
        "Because there are many different ways (actually, there's almost an infinite number of ways) to write neural networks.\n",
        "\n",
        "But the following is a generic setup for ingesting a collection of numbers, finding patterns in them and then outputting some kind of target number.\n",
        "\n",
        "Yes, the previous sentence is vague but we'll see this in action shortly.\n",
        "\n",
        "| **Hyperparameter** | **Typical value** |\n",
        "| --- | --- |\n",
        "| Input layer shape | Same shape as number of features (e.g. 3 for # bedrooms, # bathrooms, # car spaces in housing price prediction) |\n",
        "| Hidden layer(s) | Problem specific, minimum = 1, maximum = unlimited |\n",
        "| Neurons per hidden layer | Problem specific, generally 10 to 100 |\n",
        "| Output layer shape | Same shape as desired prediction shape (e.g. 1 for house price) |\n",
        "| Hidden activation | Usually [ReLU](https://www.kaggle.com/dansbecker/rectified-linear-units-relu-in-deep-learning) (rectified linear unit) |\n",
        "| Output activation | None, ReLU, logistic/tanh |\n",
        "| Loss function | [MSE](https://en.wikipedia.org/wiki/Mean_squared_error) (mean square error) or [MAE](https://en.wikipedia.org/wiki/Mean_absolute_error) (mean absolute error)/Huber (combination of MAE/MSE) if outliers |\n",
        "| Optimizer | [SGD](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/SGD) (stochastic gradient descent), [Adam](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam) |\n",
        "\n",
        "*Table 1: Typical architecture of a regression network. Source: Adapted from page 293 of [Hands-On Machine Learning with Scikit-Learn, Keras & TensorFlow Book by Aurélien Géron](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/)*\n",
        "\n",
        "Again, if you're new to neural networks and deep learning in general, much of the above table won't make sense. But don't worry, we'll be getting hands-on with all of it soon.\n",
        "\n",
        "> 🔑 **Note:** A **hyperparameter** in machine learning is something a data analyst or developer can set themselves, where as a **parameter** usually describes something a model learns on its own (a value not explicitly set by an analyst).\n",
        "\n",
        "Okay, enough talk, let's get started writing code.\n",
        "\n",
        "To use TensorFlow, we'll import it as the common alias `tf` (short for TensorFlow)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FMqsqKpk7TrH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1489d228-3978-4698-b949-ca38d3dbc9ee"
      },
      "source": [
        "import tensorflow as tf\n",
        "print(tf.__version__) # check the version (should be 2.x+)\n",
        "\n",
        "import datetime\n",
        "print(f\"Notebook last run (end-to-end): {datetime.datetime.now()}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.12.0\n",
            "Notebook last run (end-to-end): 2023-06-10 05:31:40.381955\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8clMYxrF6Mzv"
      },
      "source": [
        "## Creating data to view and fit\n",
        "\n",
        "Since we're working on a **regression problem** (predicting a number) let's create some linear data (a straight line) to model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G43tWFof6i7T",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 435
        },
        "outputId": "11a8f0a7-1ef7-42ee-e807-e7af75c6924b"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Create features\n",
        "X = np.array([-7.0, -4.0, -1.0, 2.0, 5.0, 8.0, 11.0, 14.0])\n",
        "\n",
        "# Create labels\n",
        "y = np.array([3.0, 6.0, 9.0, 12.0, 15.0, 18.0, 21.0, 24.0])\n",
        "\n",
        "# Visualize it\n",
        "plt.scatter(X, y);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ONZF8un7_xy"
      },
      "source": [
        "Before we do any modelling, can you calculate the pattern between `X` and `y`?\n",
        "\n",
        "For example, say I asked you, based on this data what the `y` value would be if `X` was 17.0?\n",
        "\n",
        "Or how about if `X` was -10.0?\n",
        "\n",
        "This kind of pattern discovery is the essence of what we'll be building neural networks to do for us."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zNCXxHnF6jjZ"
      },
      "source": [
        "## Regression input shapes and output shapes\n",
        "\n",
        "One of the most important concepts when working with neural networks are the input and output shapes.\n",
        "\n",
        "The **input shape** is the shape of your data that goes into the model.\n",
        "\n",
        "The **output shape** is the shape of your data you want to come out of your model.\n",
        "\n",
        "These will differ depending on the problem you're working on.\n",
        "\n",
        "Neural networks accept numbers and output numbers. These numbers are typically represented as tensors (or arrays).\n",
        "\n",
        "Before, we created data using NumPy arrays, but we could do the same with tensors."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XrXQ3m0prWXa",
        "outputId": "b428b76a-c69d-47c3-9fef-b93292e6a483"
      },
      "source": [
        "# Example input and output shapes of a regression model\n",
        "house_info = tf.constant([\"bedroom\", \"bathroom\", \"garage\"])\n",
        "house_price = tf.constant([939700])\n",
        "house_info, house_price"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(3,), dtype=string, numpy=array([b'bedroom', b'bathroom', b'garage'], dtype=object)>,\n",
              " <tf.Tensor: shape=(1,), dtype=int32, numpy=array([939700], dtype=int32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yi3VWKH6sRrZ",
        "outputId": "2a922505-7bcb-4fdc-9d24-5905aff67bf7"
      },
      "source": [
        "house_info.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorShape([3])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kOxyr9sR6m9X",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 435
        },
        "outputId": "db0c520a-c881-42c7-a4f7-a99a27a788ff"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Create features (using tensors)\n",
        "X = tf.constant([-7.0, -4.0, -1.0, 2.0, 5.0, 8.0, 11.0, 14.0])\n",
        "\n",
        "# Create labels (using tensors)\n",
        "y = tf.constant([3.0, 6.0, 9.0, 12.0, 15.0, 18.0, 21.0, 24.0])\n",
        "\n",
        "# Visualize it\n",
        "plt.scatter(X, y);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zaPxco6E9i1_"
      },
      "source": [
        "Our goal here will be to use `X` to predict `y`.\n",
        "\n",
        "So our **input** will be `X` and our **output** will be `y`.\n",
        "\n",
        "Knowing this, what do you think our input and output shapes will be?\n",
        "\n",
        "Let's take a look."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j1oT1gmB9iX-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7fd97cdc-5294-4e42-9b28-41268e33ba11"
      },
      "source": [
        "# Take a single example of X\n",
        "input_shape = X[0].shape \n",
        "\n",
        "# Take a single example of y\n",
        "output_shape = y[0].shape\n",
        "\n",
        "input_shape, output_shape # these are both scalars (no shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(TensorShape([]), TensorShape([]))"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m4txxFTL_EEX"
      },
      "source": [
        "Huh?\n",
        "\n",
        "From this it seems our inputs and outputs have no shape?\n",
        "\n",
        "How could that be?\n",
        "\n",
        "It's because no matter what kind of data we pass to our model, it's always going to take as input and return as output some kind of tensor.\n",
        "\n",
        "But in our case because of our dataset (only 2 small lists of numbers), we're looking at a special kind of tensor, more specifically a rank 0 tensor or a scalar."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dag5y4MPaTmc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f64d7802-9cfd-4cac-d972-d7d91702f990"
      },
      "source": [
        "# Let's take a look at the single examples invidually\n",
        "X[0], y[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(), dtype=float32, numpy=-7.0>,\n",
              " <tf.Tensor: shape=(), dtype=float32, numpy=3.0>)"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fKtihU57_cOY"
      },
      "source": [
        "In our case, we're trying to build a model to predict the pattern between `X[0]` equalling `-7.0` and `y[0]` equalling `3.0`.\n",
        "\n",
        "So now we get our answer, we're trying to use 1 `X` value to predict 1 `y` value.\n",
        "\n",
        "You might be thinking, \"this seems pretty complicated for just predicting a straight line...\".\n",
        "\n",
        "And you'd be right.\n",
        "\n",
        "But the concepts we're covering here, the concepts of input and output shapes to a model are fundamental. \n",
        "\n",
        "In fact, they're probably two of the things you'll spend the most time on when you work with neural networks: **making sure your input and outputs are in the correct shape**.\n",
        "\n",
        "If it doesn't make sense now, we'll see plenty more examples later on (soon you'll notice the input and output shapes can be almost anything you can imagine).\n",
        "\n",
        "![example of input and output shapes for a housing price prediction problem](https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/images/01-input-and-output-shapes-housing-prices.png)\n",
        "*If you were working on building a machine learning algorithm for predicting housing prices, your inputs may be number of bedrooms, number of bathrooms and number of garages, giving you an input shape of 3 (3 different features). And since you're trying to predict the price of the house, your output shape would be 1.*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PhAIqjrn6olF"
      },
      "source": [
        "## Steps in modelling with TensorFlow\n",
        "\n",
        "Now we know what data we have as well as the input and output shapes, let's see how we'd build a neural network to model it.\n",
        "\n",
        "In TensorFlow, there are typically 3 fundamental steps to creating and training a model.\n",
        "\n",
        "1. **Creating a model** - piece together the layers of a neural network yourself (using the [Functional](https://www.tensorflow.org/guide/keras/functional) or [Sequential API](https://www.tensorflow.org/api_docs/python/tf/keras/Sequential)) or import a previously built model (known as transfer learning).\n",
        "2. **Compiling a model** - defining how a models performance should be measured (loss/metrics) as well as defining how it should improve (optimizer). \n",
        "3. **Fitting a model** - letting the model try to find patterns in the data (how does `X` get to `y`). \n",
        "\n",
        "Let's see these in action using the [Keras Sequential API](https://www.tensorflow.org/api_docs/python/tf/keras/Sequential) to build a model for our regression data. And then we'll step through each.\n",
        "\n",
        "> **Note:** If you're using [TensorFlow 2.7.0](https://github.com/tensorflow/tensorflow/releases/tag/v2.7.0)+, the `fit()` function no longer upscales input data to go from `(batch_size, )` to `(batch_size, 1)`. To fix this, you'll need to expand the dimension of input data using `tf.expand_dims(input_data, axis=-1)`.\n",
        ">\n",
        "> In our case, this means instead of using `model.fit(X, y, epochs=5)`, use `model.fit(tf.expand_dims(X, axis=-1), y, epochs=5)`. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P9jj-OE16yCn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a7f37819-1109-4011-89b6-dca9f9556f91"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Create a model using the Sequential API\n",
        "model = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(1)\n",
        "])\n",
        "\n",
        "# Compile the model\n",
        "model.compile(loss=tf.keras.losses.mae, # mae is short for mean absolute error\n",
        "              optimizer=tf.keras.optimizers.SGD(), # SGD is short for stochastic gradient descent\n",
        "              metrics=[\"mae\"])\n",
        "\n",
        "# Fit the model\n",
        "# model.fit(X, y, epochs=5) # this will break with TensorFlow 2.7.0+\n",
        "model.fit(tf.expand_dims(X, axis=-1), y, epochs=5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "1/1 [==============================] - 6s 6s/step - loss: 20.6704 - mae: 20.6704\n",
            "Epoch 2/5\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 20.3312 - mae: 20.3312\n",
            "Epoch 3/5\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 20.0500 - mae: 20.0500\n",
            "Epoch 4/5\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 19.7687 - mae: 19.7687\n",
            "Epoch 5/5\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 19.4875 - mae: 19.4875\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f5bdb2afc40>"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bbjCwkEtetB9"
      },
      "source": [
        "Boom!\n",
        "\n",
        "We've just trained a model to figure out the patterns between `X` and `y`.\n",
        "\n",
        "How do you think it went?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VWLpG2U3erWo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c36321e8-e31c-48ae-d8f0-aa393d1676cf"
      },
      "source": [
        "# Check out X and y\n",
        "X, y"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(8,), dtype=float32, numpy=array([-7., -4., -1.,  2.,  5.,  8., 11., 14.], dtype=float32)>,\n",
              " <tf.Tensor: shape=(8,), dtype=float32, numpy=array([ 3.,  6.,  9., 12., 15., 18., 21., 24.], dtype=float32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ZpkaI_Oe6no"
      },
      "source": [
        "What do you think the outcome should be if we passed our model an `X` value of 17.0?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X86cD66Qeo-8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4afde941-37b4-4d6f-848f-f49b40e751f3"
      },
      "source": [
        "# Make a prediction with the model\n",
        "model.predict([17.0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 114ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-20.955889]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2YoKIqhffq33"
      },
      "source": [
        "It doesn't go very well... it should've output something close to 27.0.\n",
        "\n",
        "> 🤔 **Question:** What's Keras? I thought we were working with TensorFlow but every time we write TensorFlow code, `keras` comes after `tf` (e.g. `tf.keras.layers.Dense()`)?\n",
        "\n",
        "Before TensorFlow 2.0+, [Keras](https://keras.io/) was an API designed to be able to build deep learning models with ease. Since TensorFlow 2.0+, its functionality has been tightly integrated within the TensorFlow library."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qAPk1T3xgOm4"
      },
      "source": [
        "## Improving a model\n",
        "\n",
        "How do you think you'd improve upon our current model?\n",
        "\n",
        "If you guessed by tweaking some of the things we did above, you'd be correct.\n",
        "\n",
        "To improve our model, we alter almost every part of the 3 steps we went through before.\n",
        "\n",
        "1. **Creating a model** - here you might want to add more layers, increase the number of hidden units (also called neurons) within each layer, change the activation functions of each layer.\n",
        "2. **Compiling a model** - you might want to choose optimization function or perhaps change the **learning rate** of the optimization function.\n",
        "3. **Fitting a model** - perhaps you could fit a model for more **epochs** (leave it training for longer) or on more data (give the model more examples to learn from).\n",
        "\n",
        "![various options you can use to improve a neural network model](https://raw.githubusercontent.com/mrdbourke/tensorflow-deep-learning/main/images/02-improving-a-model-from-model-perspective.png)\n",
        "*There are many different ways to potentially improve a neural network. Some of the most common include: increasing the number of layers (making the network deeper), increasing the number of hidden units (making the network wider) and changing the learning rate. Because these values are all human-changeable, they're referred to as [hyperparameters](https://en.wikipedia.org/wiki/Hyperparameter_(machine_learning)) and the practice of trying to find the best hyperparameters is referred to as [hyperparameter tuning](https://en.wikipedia.org/wiki/Hyperparameter_optimization).*\n",
        "\n",
        "Woah. We just introduced a bunch of possible steps. The important thing to remember is how you alter each of these will depend on the problem you're working on.\n",
        "\n",
        "And the good thing is, over the next few problems, we'll get hands-on with all of them.\n",
        "\n",
        "For now, let's keep it simple, all we'll do is train our model for longer (everything else will stay the same)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MI0LammMgWcN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "38e5ec72-204a-4c15-a129-d58167fe24f3"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Create a model (same as above)\n",
        "model = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(1)\n",
        "])\n",
        "\n",
        "# Compile model (same as above)\n",
        "model.compile(loss=tf.keras.losses.mae,\n",
        "              optimizer=tf.keras.optimizers.SGD(),\n",
        "              metrics=[\"mae\"])\n",
        "\n",
        "# Fit model (this time we'll train for longer)\n",
        "model.fit(tf.expand_dims(X, axis=-1), y, epochs=100) # train for 100 epochs not 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "1/1 [==============================] - 1s 524ms/step - loss: 12.5048 - mae: 12.5048\n",
            "Epoch 2/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 12.3723 - mae: 12.3723\n",
            "Epoch 3/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 12.2398 - mae: 12.2398\n",
            "Epoch 4/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 12.1073 - mae: 12.1073\n",
            "Epoch 5/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 11.9748 - mae: 11.9748\n",
            "Epoch 6/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 11.8423 - mae: 11.8423\n",
            "Epoch 7/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 11.7098 - mae: 11.7098\n",
            "Epoch 8/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 11.5773 - mae: 11.5773\n",
            "Epoch 9/100\n",
            "1/1 [==============================] - 0s 14ms/step - loss: 11.4448 - mae: 11.4448\n",
            "Epoch 10/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 11.3123 - mae: 11.3123\n",
            "Epoch 11/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 11.1798 - mae: 11.1798\n",
            "Epoch 12/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 11.0473 - mae: 11.0473\n",
            "Epoch 13/100\n",
            "1/1 [==============================] - 0s 17ms/step - loss: 10.9148 - mae: 10.9148\n",
            "Epoch 14/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 10.7823 - mae: 10.7823\n",
            "Epoch 15/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 10.6498 - mae: 10.6498\n",
            "Epoch 16/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 10.5173 - mae: 10.5173\n",
            "Epoch 17/100\n",
            "1/1 [==============================] - 0s 15ms/step - loss: 10.3848 - mae: 10.3848\n",
            "Epoch 18/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 10.2523 - mae: 10.2523\n",
            "Epoch 19/100\n",
            "1/1 [==============================] - 0s 15ms/step - loss: 10.1198 - mae: 10.1198\n",
            "Epoch 20/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 9.9873 - mae: 9.9873\n",
            "Epoch 21/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 9.8548 - mae: 9.8548\n",
            "Epoch 22/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 9.7223 - mae: 9.7223\n",
            "Epoch 23/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 9.5898 - mae: 9.5898\n",
            "Epoch 24/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 9.4573 - mae: 9.4573\n",
            "Epoch 25/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 9.3248 - mae: 9.3248\n",
            "Epoch 26/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 9.1923 - mae: 9.1923\n",
            "Epoch 27/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 9.0598 - mae: 9.0598\n",
            "Epoch 28/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 8.9273 - mae: 8.9273\n",
            "Epoch 29/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 8.7948 - mae: 8.7948\n",
            "Epoch 30/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 8.6623 - mae: 8.6623\n",
            "Epoch 31/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 8.5298 - mae: 8.5298\n",
            "Epoch 32/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 8.3973 - mae: 8.3973\n",
            "Epoch 33/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 8.2648 - mae: 8.2648\n",
            "Epoch 34/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 8.1323 - mae: 8.1323\n",
            "Epoch 35/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.9998 - mae: 7.9998\n",
            "Epoch 36/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 7.8673 - mae: 7.8673\n",
            "Epoch 37/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 7.7348 - mae: 7.7348\n",
            "Epoch 38/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.6023 - mae: 7.6023\n",
            "Epoch 39/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.4698 - mae: 7.4698\n",
            "Epoch 40/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.3373 - mae: 7.3373\n",
            "Epoch 41/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.2048 - mae: 7.2048\n",
            "Epoch 42/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.1925 - mae: 7.1925\n",
            "Epoch 43/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 7.1869 - mae: 7.1869\n",
            "Epoch 44/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 7.1812 - mae: 7.1812\n",
            "Epoch 45/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.1756 - mae: 7.1756\n",
            "Epoch 46/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 7.1700 - mae: 7.1700\n",
            "Epoch 47/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.1644 - mae: 7.1644\n",
            "Epoch 48/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.1588 - mae: 7.1588\n",
            "Epoch 49/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 7.1531 - mae: 7.1531\n",
            "Epoch 50/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 7.1475 - mae: 7.1475\n",
            "Epoch 51/100\n",
            "1/1 [==============================] - 0s 16ms/step - loss: 7.1419 - mae: 7.1419\n",
            "Epoch 52/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 7.1363 - mae: 7.1363\n",
            "Epoch 53/100\n",
            "1/1 [==============================] - 0s 14ms/step - loss: 7.1306 - mae: 7.1306\n",
            "Epoch 54/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.1250 - mae: 7.1250\n",
            "Epoch 55/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.1194 - mae: 7.1194\n",
            "Epoch 56/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 7.1138 - mae: 7.1138\n",
            "Epoch 57/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 7.1081 - mae: 7.1081\n",
            "Epoch 58/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.1025 - mae: 7.1025\n",
            "Epoch 59/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.0969 - mae: 7.0969\n",
            "Epoch 60/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.0913 - mae: 7.0913\n",
            "Epoch 61/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.0856 - mae: 7.0856\n",
            "Epoch 62/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.0800 - mae: 7.0800\n",
            "Epoch 63/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 7.0744 - mae: 7.0744\n",
            "Epoch 64/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 7.0687 - mae: 7.0687\n",
            "Epoch 65/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 7.0631 - mae: 7.0631\n",
            "Epoch 66/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 7.0575 - mae: 7.0575\n",
            "Epoch 67/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 7.0519 - mae: 7.0519\n",
            "Epoch 68/100\n",
            "1/1 [==============================] - 0s 8ms/step - loss: 7.0463 - mae: 7.0463\n",
            "Epoch 69/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 7.0406 - mae: 7.0406\n",
            "Epoch 70/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 7.0350 - mae: 7.0350\n",
            "Epoch 71/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 7.0294 - mae: 7.0294\n",
            "Epoch 72/100\n",
            "1/1 [==============================] - 0s 14ms/step - loss: 7.0238 - mae: 7.0238\n",
            "Epoch 73/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.0181 - mae: 7.0181\n",
            "Epoch 74/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 7.0125 - mae: 7.0125\n",
            "Epoch 75/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 7.0069 - mae: 7.0069\n",
            "Epoch 76/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 7.0013 - mae: 7.0013\n",
            "Epoch 77/100\n",
            "1/1 [==============================] - 0s 8ms/step - loss: 6.9956 - mae: 6.9956\n",
            "Epoch 78/100\n",
            "1/1 [==============================] - 0s 15ms/step - loss: 6.9900 - mae: 6.9900\n",
            "Epoch 79/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 6.9844 - mae: 6.9844\n",
            "Epoch 80/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 6.9788 - mae: 6.9788\n",
            "Epoch 81/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 6.9731 - mae: 6.9731\n",
            "Epoch 82/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 6.9675 - mae: 6.9675\n",
            "Epoch 83/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 6.9619 - mae: 6.9619\n",
            "Epoch 84/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 6.9563 - mae: 6.9563\n",
            "Epoch 85/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 6.9506 - mae: 6.9506\n",
            "Epoch 86/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 6.9450 - mae: 6.9450\n",
            "Epoch 87/100\n",
            "1/1 [==============================] - 0s 12ms/step - loss: 6.9394 - mae: 6.9394\n",
            "Epoch 88/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 6.9338 - mae: 6.9338\n",
            "Epoch 89/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 6.9281 - mae: 6.9281\n",
            "Epoch 90/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 6.9225 - mae: 6.9225\n",
            "Epoch 91/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 6.9169 - mae: 6.9169\n",
            "Epoch 92/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 6.9113 - mae: 6.9113\n",
            "Epoch 93/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 6.9056 - mae: 6.9056\n",
            "Epoch 94/100\n",
            "1/1 [==============================] - 0s 9ms/step - loss: 6.9000 - mae: 6.9000\n",
            "Epoch 95/100\n",
            "1/1 [==============================] - 0s 13ms/step - loss: 6.8944 - mae: 6.8944\n",
            "Epoch 96/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 6.8888 - mae: 6.8888\n",
            "Epoch 97/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 6.8831 - mae: 6.8831\n",
            "Epoch 98/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 6.8775 - mae: 6.8775\n",
            "Epoch 99/100\n",
            "1/1 [==============================] - 0s 11ms/step - loss: 6.8719 - mae: 6.8719\n",
            "Epoch 100/100\n",
            "1/1 [==============================] - 0s 10ms/step - loss: 6.8663 - mae: 6.8663\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f5bdadc1540>"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1CIKSm7filgj"
      },
      "source": [
        "You might've noticed the loss value decrease from before (and keep decreasing as the number of epochs gets higher). \n",
        "\n",
        "What do you think this means for when we make a prediction with our model?\n",
        "\n",
        "How about we try predict on 17.0 again?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_YcacZsfi4zZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8b8b1cd-060c-4389-fc6c-92ce84ec48b3"
      },
      "source": [
        "# Remind ourselves of what X and y are\n",
        "X, y"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<tf.Tensor: shape=(8,), dtype=float32, numpy=array([-7., -4., -1.,  2.,  5.,  8., 11., 14.], dtype=float32)>,\n",
              " <tf.Tensor: shape=(8,), dtype=float32, numpy=array([ 3.,  6.,  9., 12., 15., 18., 21., 24.], dtype=float32)>)"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e6k5V08ZivNO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "22763449-76b4-4420-8151-58ed2c81d8d9"
      },
      "source": [
        "# Try and predict what y would be if X was 17.0\n",
        "model.predict([17.0]) # the right answer is 27.0 (y = X + 10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 54ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[30.081324]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sYi5V8ZYi_dy"
      },
      "source": [
        "Much better! \n",
        "\n",
        "We got closer this time. But we could still be better.\n",
        "\n",
        "Now we've trained a model, how could we evaluate it?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HvC98q_h6zvG"
      },
      "source": [
        "## Evaluating a model \n",
        "\n",
        "A typical workflow you'll go through when building neural networks is:\n",
        "\n",
        "```\n",
        "Build a model -> evaluate it -> build (tweak) a model -> evaulate it -> build (tweak) a model -> evaluate it...\n",
        "```\n",
        "\n",
        "The tweaking comes from maybe not building a model from scratch but adjusting an existing one.\n",
        "\n",
        "### Visualize, visualize, visualize\n",
        "\n",
        "When it comes to evaluation, you'll want to remember the words: \"visualize, visualize, visualize.\" \n",
        "\n",
        "This is because you're probably better looking at something (doing) than you are thinking about something.\n",
        "\n",
        "It's a good idea to visualize:\n",
        "* **The data** - what data are you working with? What does it look like?\n",
        "* **The model itself** - what does the architecture look like? What are the different shapes?\n",
        "* **The training of a model** - how does a model perform while it learns?\n",
        "* **The predictions of a model** - how do the predictions of a model line up against the ground truth (the original labels)?\n",
        "\n",
        "Let's start by visualizing the model.\n",
        "\n",
        "But first, we'll create a little bit of a bigger dataset and a new model we can use (it'll be the same as before, but the more practice the better).\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "srxuqbeYopns",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb55e2b2-c1de-4046-de39-00c8f99136f2"
      },
      "source": [
        "# Make a bigger dataset\n",
        "X = np.arange(-100, 100, 4)\n",
        "X"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-100,  -96,  -92,  -88,  -84,  -80,  -76,  -72,  -68,  -64,  -60,\n",
              "        -56,  -52,  -48,  -44,  -40,  -36,  -32,  -28,  -24,  -20,  -16,\n",
              "        -12,   -8,   -4,    0,    4,    8,   12,   16,   20,   24,   28,\n",
              "         32,   36,   40,   44,   48,   52,   56,   60,   64,   68,   72,\n",
              "         76,   80,   84,   88,   92,   96])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pQcC0nSko3kJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fd28ed49-c664-4a11-efa9-dbb119b42ac2"
      },
      "source": [
        "# Make labels for the dataset (adhering to the same pattern as before)\n",
        "y = np.arange(-90, 110, 4)\n",
        "y"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-90, -86, -82, -78, -74, -70, -66, -62, -58, -54, -50, -46, -42,\n",
              "       -38, -34, -30, -26, -22, -18, -14, -10,  -6,  -2,   2,   6,  10,\n",
              "        14,  18,  22,  26,  30,  34,  38,  42,  46,  50,  54,  58,  62,\n",
              "        66,  70,  74,  78,  82,  86,  90,  94,  98, 102, 106])"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KNIw5tgGpKjb"
      },
      "source": [
        "Since $y=X+10$, we could make the labels like so:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ACgbmrAOpJwW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "708ade9f-a7be-4e63-bac2-ca7c7eda9a97"
      },
      "source": [
        "# Same result as above\n",
        "y = X + 10\n",
        "y"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-90, -86, -82, -78, -74, -70, -66, -62, -58, -54, -50, -46, -42,\n",
              "       -38, -34, -30, -26, -22, -18, -14, -10,  -6,  -2,   2,   6,  10,\n",
              "        14,  18,  22,  26,  30,  34,  38,  42,  46,  50,  54,  58,  62,\n",
              "        66,  70,  74,  78,  82,  86,  90,  94,  98, 102, 106])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ax3MnQDupeBp"
      },
      "source": [
        "## Split data into training/test set\n",
        "\n",
        "One of the other most common and important steps in a machine learning project is creating a training and test set (and when required, a validation set).\n",
        "\n",
        "Each set serves a specific purpose:\n",
        "* **Training set** - the model learns from this data, which is typically 70-80% of the total data available (like the course materials you study during the semester).\n",
        "* **Validation set** - the model gets tuned on this data, which is typically 10-15% of the total data available (like the practice exam you take before the final exam).\n",
        "* **Test set** - the model gets evaluated on this data to test what it has learned, it's typically 10-15% of the total data available (like the final exam you take at the end of the semester).\n",
        "\n",
        "For now, we'll just use a training and test set, this means we'll have a dataset for our model to learn on as well as be evaluated on.\n",
        "\n",
        "We can create them by splitting our `X` and `y` arrays.\n",
        "\n",
        "> 🔑 **Note:** When dealing with real-world data, this step is typically done right at the start of a project (the test set should always be kept separate from all other data). We want our model to learn on training data and then evaluate it on test data to get an indication of how well it **generalizes** to unseen examples."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5G0RDMnZrgvK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "92310264-615e-4013-e117-82ff0f2a016d"
      },
      "source": [
        "# Check how many samples we have\n",
        "len(X)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "50"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Q9ptcQkrGfO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "286fe787-29b2-4bfb-b5e3-ee0b77a2da35"
      },
      "source": [
        "# Split data into train and test sets\n",
        "X_train = X[:40] # first 40 examples (80% of data)\n",
        "y_train = y[:40]\n",
        "\n",
        "X_test = X[40:] # last 10 examples (20% of data)\n",
        "y_test = y[40:]\n",
        "\n",
        "len(X_train), len(X_test)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rz2cIdECsLH5"
      },
      "source": [
        "## Visualizing the data\n",
        "\n",
        "Now we've got our training and test data, it's a good idea to visualize it.\n",
        "\n",
        "Let's plot it with some nice colours to differentiate what's what."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "os30CXBHsOAH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "outputId": "68e6dd27-0f3d-4e1d-bd7c-5c5f432c8d70"
      },
      "source": [
        "plt.figure(figsize=(10, 7))\n",
        "# Plot training data in blue\n",
        "plt.scatter(X_train, y_train, c='b', label='Training data')\n",
        "# Plot test data in green\n",
        "plt.scatter(X_test, y_test, c='g', label='Testing data')\n",
        "# Show the legend\n",
        "plt.legend();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cxRcHZFgtS_B"
      },
      "source": [
        "Beautiful! Any time you can visualize your data, your model, your anything, it's a good idea. \n",
        "\n",
        "With this graph in mind, what we'll be trying to do is build a model which learns the pattern in the blue dots (`X_train`) to draw the green dots (`X_test`).\n",
        "\n",
        "Time to build a model. We'll make the exact same one from before (the one we trained for longer)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4qpe0eSStSm-"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Create a model (same as above)\n",
        "model = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(1)\n",
        "])\n",
        "\n",
        "# Compile model (same as above)\n",
        "model.compile(loss=tf.keras.losses.mae,\n",
        "              optimizer=tf.keras.optimizers.SGD(),\n",
        "              metrics=[\"mae\"])\n",
        "\n",
        "# Fit model (same as above)\n",
        "#model.fit(X_train, y_train, epochs=100) # commented out on purpose (not fitting it just yet)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hc2RHCCfqlAc"
      },
      "source": [
        "## Visualizing the model\n",
        "\n",
        "After you've built a model, you might want to take a look at it (especially if you haven't built many before).\n",
        "\n",
        "You can take a look at the layers and shapes of your model by calling [`summary()`](https://www.tensorflow.org/api_docs/python/tf/keras/Model#summary) on it.\n",
        "\n",
        "> 🔑 **Note:** Visualizing a model is particularly helpful when you run into input and output shape mismatches."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OlgJj0cFwChH"
      },
      "source": [
        "# Doesn't work (model not fit/built)\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SJj6KLe8xsyF"
      },
      "source": [
        "Ahh, the cell above errors because we haven't fit or built our model.\n",
        "\n",
        "We also haven't told it what input shape it should be expecting.\n",
        "\n",
        "Remember above, how we discussed the input shape was just one number?\n",
        "\n",
        "We can let our model know the input shape of our data using the `input_shape` parameter to the first layer (usually if `input_shape` isn't defined, Keras tries to figure it out automatically)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zMXKFtFBuWgJ"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Create a model (same as above)\n",
        "model = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(1, input_shape=[1]) # define the input_shape to our model\n",
        "])\n",
        "\n",
        "# Compile model (same as above)\n",
        "model.compile(loss=tf.keras.losses.mae,\n",
        "              optimizer=tf.keras.optimizers.SGD(),\n",
        "              metrics=[\"mae\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "24Q325x2yCoi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "150a3219-4a8c-4b94-c131-351e9a57e2b0"
      },
      "source": [
        "# This will work after specifying the input shape\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_5\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_5 (Dense)             (None, 1)                 2         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 2\n",
            "Trainable params: 2\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jdurWKlryl6b"
      },
      "source": [
        "Calling `summary()` on our model shows us the layers it contains, the output shape and the number of parameters.\n",
        "* **Total params** - total number of parameters in the model.\n",
        "* **Trainable parameters** - these are the parameters (patterns) the model can update as it trains.\n",
        "* **Non-trainable parameters** - these parameters aren't updated during training (this is typical when you bring in the already learned patterns from other models during transfer learning).\n",
        "\n",
        "> 📖 **Resource:** For a more in-depth overview of the trainable parameters within a layer, check out [MIT's introduction to deep learning video](https://youtu.be/njKP3FqW3Sk).\n",
        "\n",
        "> 🛠 **Exercise:** Try playing around with the number of hidden units in the `Dense` layer (e.g. `Dense(2)`, `Dense(3)`). How does this change the Total/Trainable params? Investigate what's causing the change.\n",
        "\n",
        "For now, all you need to think about these parameters is that their learnable patterns in the data.\n",
        "\n",
        "Let's fit our model to the training data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Kywg4q9u051",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5e98f821-ad95-4ae8-8dab-be26febefda6"
      },
      "source": [
        "# Fit the model to the training data\n",
        "model.fit(X_train, y_train, epochs=100, verbose=0) # verbose controls how much gets output"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f5bdab4df00>"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-jWuOwj961ri",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "034afeac-a32f-49ed-b334-c87b251a6014"
      },
      "source": [
        "# Check the model summary\n",
        "model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_5\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_5 (Dense)             (None, 1)                 2         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 2\n",
            "Trainable params: 2\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RrrkHEkMYh5A"
      },
      "source": [
        "Alongside summary, you can also view a 2D plot of the model using [`plot_model()`](https://www.tensorflow.org/api_docs/python/tf/keras/utils/plot_model)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "liIg5WqDfdK4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 201
        },
        "outputId": "0746da1c-7810-4b59-80cb-ee11069bde8f"
      },
      "source": [
        "from tensorflow.keras.utils import plot_model\n",
        "\n",
        "plot_model(model, show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ygw7V8OVYxQS"
      },
      "source": [
        "In our case, the model we used only has an input and an output but visualizing more complicated models can be very helpful for debugging."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gebj2eptqwg8"
      },
      "source": [
        "## Visualizing the predictions\n",
        "\n",
        "Now we've got a trained model, let's visualize some predictions.\n",
        "\n",
        "To visualize predictions, it's always a good idea to plot them against the ground truth labels.\n",
        "\n",
        "Often you'll see this in the form of `y_test` vs. `y_pred` (ground truth vs. predictions).\n",
        "\n",
        "First, we'll make some predictions on the test data (`X_test`), remember the model has never seen the test data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RRzj7LJMYftb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "52fc73b3-f85f-4c4c-d5e4-5b182c9ff6d6"
      },
      "source": [
        "# Make predictions\n",
        "y_preds = model.predict(X_test)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 41ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_hKpW-KOZiAW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7397ec4e-e862-4d89-e8ff-7f37f419e959"
      },
      "source": [
        "# View the predictions\n",
        "y_preds"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 74.383286],\n",
              "       [ 79.25688 ],\n",
              "       [ 84.13048 ],\n",
              "       [ 89.004074],\n",
              "       [ 93.87766 ],\n",
              "       [ 98.75126 ],\n",
              "       [103.624855],\n",
              "       [108.49844 ],\n",
              "       [113.37204 ],\n",
              "       [118.245636]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aPRaFncaZnT-"
      },
      "source": [
        "Okay, we get a list of numbers but how do these compare to the ground truth labels?\n",
        "\n",
        "Let's build a plotting function to find out.\n",
        "\n",
        "> 🔑 **Note:** If you think you're going to be visualizing something a lot, it's a good idea to functionize it so you can use it later."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "56euC69rZvNJ"
      },
      "source": [
        "def plot_predictions(train_data=X_train, \n",
        "                     train_labels=y_train, \n",
        "                     test_data=X_test, \n",
        "                     test_labels=y_test, \n",
        "                     predictions=y_preds):\n",
        "  \"\"\"\n",
        "  Plots training data, test data and compares predictions.\n",
        "  \"\"\"\n",
        "  plt.figure(figsize=(10, 7))\n",
        "  # Plot training data in blue\n",
        "  plt.scatter(train_data, train_labels, c=\"b\", label=\"Training data\")\n",
        "  # Plot test data in green\n",
        "  plt.scatter(test_data, test_labels, c=\"g\", label=\"Testing data\")\n",
        "  # Plot the predictions in red (predictions were made on the test data)\n",
        "  plt.scatter(test_data, predictions, c=\"r\", label=\"Predictions\")\n",
        "  # Show the legend\n",
        "  plt.legend();"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fug5_B6Ab7Ah",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "outputId": "42a0daa7-b1c1-4cee-b720-fd3019c73d68"
      },
      "source": [
        "plot_predictions(train_data=X_train,\n",
        "                 train_labels=y_train,\n",
        "                 test_data=X_test,\n",
        "                 test_labels=y_test,\n",
        "                 predictions=y_preds)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H63NPcgPcwZV"
      },
      "source": [
        "From the plot we can see our predictions aren't totally outlandish but they definitely aren't anything special either."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "orAfIWOrgRDA"
      },
      "source": [
        "## Evaluating predictions\n",
        "\n",
        "Alongisde visualizations, evaulation metrics are your alternative best option for evaluating your model.\n",
        "\n",
        "Depending on the problem you're working on, different models have different evaluation metrics. \n",
        "\n",
        "Two of the main metrics used for regression problems are:\n",
        "* **Mean absolute error (MAE)** - the mean difference between each of the predictions.\n",
        "* **Mean squared error (MSE)** - the squared mean difference between of the predictions (use if larger errors are more detrimental than smaller errors).\n",
        "\n",
        "The lower each of these values, the better.\n",
        "\n",
        "You can also use [`model.evaluate()`](https://www.tensorflow.org/api_docs/python/tf/keras/Model#evaluate) which will return the loss of the model as well as any metrics setup during the compile step."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DPgTdF3ddxiY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "982f8d08-e763-46e4-b2d5-49d8c87153b4"
      },
      "source": [
        "# Evaluate the model on the test set\n",
        "model.evaluate(X_test, y_test)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 113ms/step - loss: 8.3145 - mae: 8.3145\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[8.314461708068848, 8.314461708068848]"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DAXIRyVzegFd"
      },
      "source": [
        "In our case, since we used MAE for the loss function as well as MAE for the metrics, `model.evaulate()` returns them both.\n",
        "\n",
        "TensorFlow also has built in functions for MSE and MAE.\n",
        "\n",
        "For many evaluation functions, the premise is the same: compare predictions to the ground truth labels."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gqoMQ0dJeD2S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b84f50fa-f878-4217-e571-c63b5435fc39"
      },
      "source": [
        "# Calculate the mean absolute error\n",
        "mae = tf.metrics.mean_absolute_error(y_true=y_test, \n",
        "                                     y_pred=y_preds)\n",
        "mae"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(10,), dtype=float32, numpy=\n",
              "array([14.570028, 11.897247, 10.373904, 10.      , 10.775533, 12.850756,\n",
              "       16.099884, 20.498444, 25.37204 , 30.245636], dtype=float32)>"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7pYp3XNYfkyC"
      },
      "source": [
        "Huh? That's strange, MAE should be a single output.\n",
        "\n",
        "Instead, we get 10 values.\n",
        "\n",
        "This is because our `y_test` and `y_preds` tensors are different shapes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zeUHwOc2gIV4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "919148e3-aa6b-4be8-83c6-1a4c472be8bf"
      },
      "source": [
        "# Check the test label tensor values\n",
        "y_test"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 70,  74,  78,  82,  86,  90,  94,  98, 102, 106])"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3aJwlTxugPyc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0e16ca9a-f899-400f-975f-a47ea2ab51c8"
      },
      "source": [
        "# Check the predictions tensor values (notice the extra square brackets)\n",
        "y_preds"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 74.383286],\n",
              "       [ 79.25688 ],\n",
              "       [ 84.13048 ],\n",
              "       [ 89.004074],\n",
              "       [ 93.87766 ],\n",
              "       [ 98.75126 ],\n",
              "       [103.624855],\n",
              "       [108.49844 ],\n",
              "       [113.37204 ],\n",
              "       [118.245636]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xolZ-lmge_ES",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fb4f1446-d488-4ab6-a55e-7fdb451c51dd"
      },
      "source": [
        "# Check the tensor shapes\n",
        "y_test.shape, y_preds.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((10,), (10, 1))"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eW1qleu5gHyZ"
      },
      "source": [
        "Remember how we discussed dealing with different input and output shapes is one the most common issues you'll come across, this is one of those times.\n",
        "\n",
        "But not to worry.\n",
        "\n",
        "We can fix it using [`squeeze()`](https://www.tensorflow.org/api_docs/python/tf/squeeze), it'll remove the the `1` dimension from our `y_preds` tensor, making it the same shape as `y_test`.\n",
        "\n",
        "> 🔑 **Note:** If you're comparing two tensors, it's important to make sure they're the right shape(s) (you won't always have to manipulate the shapes, but always be on the look out, *many* errors are the result of mismatched tensors, especially mismatched input and output shapes)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tVtMyw70g4aF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9dd2a324-7ba2-468b-b6de-879b76185db8"
      },
      "source": [
        "# Shape before squeeze()\n",
        "y_preds.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(10, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qnYaBnCng-Nq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aeda5389-1847-48c8-a96b-aeeeed5a864f"
      },
      "source": [
        "# Shape after squeeze()\n",
        "y_preds.squeeze().shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(10,)"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HxvVeD64hEX8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cf75674b-418b-4469-9e09-e8de10a48528"
      },
      "source": [
        "# What do they look like?\n",
        "y_test, y_preds.squeeze()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([ 70,  74,  78,  82,  86,  90,  94,  98, 102, 106]),\n",
              " array([ 74.383286,  79.25688 ,  84.13048 ,  89.004074,  93.87766 ,\n",
              "         98.75126 , 103.624855, 108.49844 , 113.37204 , 118.245636],\n",
              "       dtype=float32))"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mfUCIeHyhLk7"
      },
      "source": [
        "Okay, now we know how to make our `y_test` and `y_preds` tenors the same shape, let's use our evaluation metrics."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TvjY6GIJvXBO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cd4f0f6f-a637-4dfd-aa1c-615d60275e16"
      },
      "source": [
        "# Calcuate the MAE\n",
        "mae = tf.metrics.mean_absolute_error(y_true=y_test, \n",
        "                                     y_pred=y_preds.squeeze()) # use squeeze() to make same shape\n",
        "mae"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=8.314462>"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EwA9nGJzvbMT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d69256ac-5688-4f6c-d349-25a4e694caa3"
      },
      "source": [
        "# Calculate the MSE\n",
        "mse = tf.metrics.mean_squared_error(y_true=y_test,\n",
        "                                    y_pred=y_preds.squeeze())\n",
        "mse"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float32, numpy=75.42639>"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X06oo_CIjPbL"
      },
      "source": [
        "We can also calculate the MAE using pure TensorFlow functions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YxiD6-QBYSzd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8ee8866-db77-4104-9797-ae5aac80c1ca"
      },
      "source": [
        "# Returns the same as tf.metrics.mean_absolute_error()\n",
        "tf.reduce_mean(tf.abs(y_test-y_preds.squeeze()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(), dtype=float64, numpy=8.314461517333985>"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rmEho4lYofOa"
      },
      "source": [
        "Again, it's a good idea to functionize anything you think you might use over again (or find yourself using over and over again).\n",
        "\n",
        "Let's make functions for our evaluation metrics."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bs1Z2jgNol5f"
      },
      "source": [
        "def mae(y_test, y_pred):\n",
        "  \"\"\"\n",
        "  Calculuates mean absolute error between y_test and y_preds.\n",
        "  \"\"\"\n",
        "  return tf.metrics.mean_absolute_error(y_test,\n",
        "                                        y_pred)\n",
        "  \n",
        "def mse(y_test, y_pred):\n",
        "  \"\"\"\n",
        "  Calculates mean squared error between y_test and y_preds.\n",
        "  \"\"\"\n",
        "  return tf.metrics.mean_squared_error(y_test,\n",
        "                                       y_pred)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zub5zK7bcl40"
      },
      "source": [
        "## Running experiments to improve a model\n",
        "\n",
        "After seeing the evaluation metrics and the predictions your model makes, it's likely you'll want to improve it.\n",
        "\n",
        "Again, there are many different ways you can do this, but 3 of the main ones are:\n",
        "1. **Get more data** - get more examples for your model to train on (more opportunities to learn patterns).\n",
        "2. **Make your model larger (use a more complex model)** - this might come in the form of more layers or more hidden units in each layer.\n",
        "3. **Train for longer** - give your model more of a chance to find the patterns in the data.\n",
        "\n",
        "Since we created our dataset, we could easily make more data but this isn't always the case when you're working with real-world datasets.\n",
        "\n",
        "So let's take a look at how we can improve our model using 2 and 3.\n",
        "\n",
        "To do so, we'll build 3 models and compare their results:\n",
        "1. `model_1` - same as original model, 1 layer, trained for 100 epochs.\n",
        "2. `model_2` - 2 layers, trained for 100 epochs.\n",
        "3. `model_3` - 2 layers, trained for 500 epochs.\n",
        "\n",
        "**Build `model_1`**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "StVHIIM9csyS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1cd75a64-e85d-4313-96a9-8cdb0c7e1692"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Replicate original model\n",
        "model_1 = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(1)\n",
        "])\n",
        "\n",
        "# Compile the model\n",
        "model_1.compile(loss=tf.keras.losses.mae,\n",
        "                optimizer=tf.keras.optimizers.SGD(),\n",
        "                metrics=['mae'])\n",
        "\n",
        "# Fit the model\n",
        "model_1.fit(tf.expand_dims(X_train, axis=-1), y_train, epochs=100)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "2/2 [==============================] - 0s 20ms/step - loss: 56.1611 - mae: 56.1611\n",
            "Epoch 2/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 21.8694 - mae: 21.8694\n",
            "Epoch 3/100\n",
            "2/2 [==============================] - 0s 8ms/step - loss: 11.0343 - mae: 11.0343\n",
            "Epoch 4/100\n",
            "2/2 [==============================] - 0s 8ms/step - loss: 9.4531 - mae: 9.4531\n",
            "Epoch 5/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 10.3427 - mae: 10.3427\n",
            "Epoch 6/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 9.5863 - mae: 9.5863\n",
            "Epoch 7/100\n",
            "2/2 [==============================] - 0s 7ms/step - loss: 8.7026 - mae: 8.7026\n",
            "Epoch 8/100\n",
            "2/2 [==============================] - 0s 8ms/step - loss: 9.0677 - mae: 9.0677\n",
            "Epoch 9/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 19.0583 - mae: 19.0583\n",
            "Epoch 10/100\n",
            "2/2 [==============================] - 0s 27ms/step - loss: 10.2940 - mae: 10.2940\n",
            "Epoch 11/100\n",
            "2/2 [==============================] - 0s 13ms/step - loss: 8.4759 - mae: 8.4759\n",
            "Epoch 12/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 10.8103 - mae: 10.8103\n",
            "Epoch 13/100\n",
            "2/2 [==============================] - 0s 21ms/step - loss: 9.8736 - mae: 9.8736\n",
            "Epoch 14/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 12.0428 - mae: 12.0428\n",
            "Epoch 15/100\n",
            "2/2 [==============================] - 0s 19ms/step - loss: 12.4743 - mae: 12.4743\n",
            "Epoch 16/100\n",
            "2/2 [==============================] - 0s 14ms/step - loss: 7.9234 - mae: 7.9234\n",
            "Epoch 17/100\n",
            "2/2 [==============================] - 0s 8ms/step - loss: 12.8458 - mae: 12.8458\n",
            "Epoch 18/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 10.4744 - mae: 10.4744\n",
            "Epoch 19/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 19.2575 - mae: 19.2575\n",
            "Epoch 20/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 15.9224 - mae: 15.9224\n",
            "Epoch 21/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 11.7513 - mae: 11.7513\n",
            "Epoch 22/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 8.9556 - mae: 8.9556\n",
            "Epoch 23/100\n",
            "2/2 [==============================] - 0s 17ms/step - loss: 10.0563 - mae: 10.0563\n",
            "Epoch 24/100\n",
            "2/2 [==============================] - 0s 13ms/step - loss: 15.6494 - mae: 15.6494\n",
            "Epoch 25/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 12.1162 - mae: 12.1162\n",
            "Epoch 26/100\n",
            "2/2 [==============================] - 0s 13ms/step - loss: 13.2293 - mae: 13.2293\n",
            "Epoch 27/100\n",
            "2/2 [==============================] - 0s 15ms/step - loss: 10.6930 - mae: 10.6930\n",
            "Epoch 28/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 12.9235 - mae: 12.9235\n",
            "Epoch 29/100\n",
            "2/2 [==============================] - 0s 16ms/step - loss: 9.5252 - mae: 9.5252\n",
            "Epoch 30/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 16.4622 - mae: 16.4622\n",
            "Epoch 31/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 23.5402 - mae: 23.5402\n",
            "Epoch 32/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 7.6134 - mae: 7.6134\n",
            "Epoch 33/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 9.3080 - mae: 9.3080\n",
            "Epoch 34/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 13.6600 - mae: 13.6600\n",
            "Epoch 35/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 11.1817 - mae: 11.1817\n",
            "Epoch 36/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 13.4189 - mae: 13.4189\n",
            "Epoch 37/100\n",
            "2/2 [==============================] - 0s 13ms/step - loss: 9.4496 - mae: 9.4496\n",
            "Epoch 38/100\n",
            "2/2 [==============================] - 0s 19ms/step - loss: 10.0999 - mae: 10.0999\n",
            "Epoch 39/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 8.9771 - mae: 8.9771\n",
            "Epoch 40/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 9.6049 - mae: 9.6049\n",
            "Epoch 41/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 10.5646 - mae: 10.5646\n",
            "Epoch 42/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 10.6171 - mae: 10.6171\n",
            "Epoch 43/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 7.2182 - mae: 7.2182\n",
            "Epoch 44/100\n",
            "2/2 [==============================] - 0s 13ms/step - loss: 8.0191 - mae: 8.0191\n",
            "Epoch 45/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 9.8194 - mae: 9.8194\n",
            "Epoch 46/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 8.8983 - mae: 8.8983\n",
            "Epoch 47/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 7.5751 - mae: 7.5751\n",
            "Epoch 48/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 8.5491 - mae: 8.5491\n",
            "Epoch 49/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 10.0295 - mae: 10.0295\n",
            "Epoch 50/100\n",
            "2/2 [==============================] - 0s 14ms/step - loss: 8.9966 - mae: 8.9966\n",
            "Epoch 51/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 10.7046 - mae: 10.7046\n",
            "Epoch 52/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 15.2746 - mae: 15.2746\n",
            "Epoch 53/100\n",
            "2/2 [==============================] - 0s 18ms/step - loss: 14.3022 - mae: 14.3022\n",
            "Epoch 54/100\n",
            "2/2 [==============================] - 0s 15ms/step - loss: 21.5628 - mae: 21.5628\n",
            "Epoch 55/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 16.0389 - mae: 16.0389\n",
            "Epoch 56/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 10.2601 - mae: 10.2601\n",
            "Epoch 57/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 9.7954 - mae: 9.7954\n",
            "Epoch 58/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 9.0787 - mae: 9.0787\n",
            "Epoch 59/100\n",
            "2/2 [==============================] - 0s 16ms/step - loss: 8.2822 - mae: 8.2822\n",
            "Epoch 60/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 9.3764 - mae: 9.3764\n",
            "Epoch 61/100\n",
            "2/2 [==============================] - 0s 18ms/step - loss: 11.2007 - mae: 11.2007\n",
            "Epoch 62/100\n",
            "2/2 [==============================] - 0s 26ms/step - loss: 12.0475 - mae: 12.0475\n",
            "Epoch 63/100\n",
            "2/2 [==============================] - 0s 15ms/step - loss: 7.2781 - mae: 7.2781\n",
            "Epoch 64/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 12.4620 - mae: 12.4620\n",
            "Epoch 65/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 10.5366 - mae: 10.5366\n",
            "Epoch 66/100\n",
            "2/2 [==============================] - 0s 19ms/step - loss: 15.5795 - mae: 15.5795\n",
            "Epoch 67/100\n",
            "2/2 [==============================] - 0s 14ms/step - loss: 9.9918 - mae: 9.9918\n",
            "Epoch 68/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 8.7174 - mae: 8.7174\n",
            "Epoch 69/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 13.4561 - mae: 13.4561\n",
            "Epoch 70/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 7.4758 - mae: 7.4758\n",
            "Epoch 71/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 12.2635 - mae: 12.2635\n",
            "Epoch 72/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 8.5191 - mae: 8.5191\n",
            "Epoch 73/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 7.0433 - mae: 7.0433\n",
            "Epoch 74/100\n",
            "2/2 [==============================] - 0s 17ms/step - loss: 9.9004 - mae: 9.9004\n",
            "Epoch 75/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 9.9641 - mae: 9.9641\n",
            "Epoch 76/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 10.1253 - mae: 10.1253\n",
            "Epoch 77/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 12.9935 - mae: 12.9935\n",
            "Epoch 78/100\n",
            "2/2 [==============================] - 0s 10ms/step - loss: 10.9010 - mae: 10.9010\n",
            "Epoch 79/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 15.3817 - mae: 15.3817\n",
            "Epoch 80/100\n",
            "2/2 [==============================] - 0s 18ms/step - loss: 11.7351 - mae: 11.7351\n",
            "Epoch 81/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 9.2554 - mae: 9.2554\n",
            "Epoch 82/100\n",
            "2/2 [==============================] - 0s 9ms/step - loss: 12.7347 - mae: 12.7347\n",
            "Epoch 83/100\n",
            "2/2 [==============================] - 0s 15ms/step - loss: 8.2882 - mae: 8.2882\n",
            "Epoch 84/100\n",
            "2/2 [==============================] - 0s 15ms/step - loss: 7.3117 - mae: 7.3117\n",
            "Epoch 85/100\n",
            "2/2 [==============================] - 0s 14ms/step - loss: 10.4732 - mae: 10.4732\n",
            "Epoch 86/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 9.1454 - mae: 9.1454\n",
            "Epoch 87/100\n",
            "2/2 [==============================] - 0s 18ms/step - loss: 11.8573 - mae: 11.8573\n",
            "Epoch 88/100\n",
            "2/2 [==============================] - 0s 19ms/step - loss: 10.4662 - mae: 10.4662\n",
            "Epoch 89/100\n",
            "2/2 [==============================] - 0s 18ms/step - loss: 6.9753 - mae: 6.9753\n",
            "Epoch 90/100\n",
            "2/2 [==============================] - 0s 14ms/step - loss: 13.7911 - mae: 13.7911\n",
            "Epoch 91/100\n",
            "2/2 [==============================] - 0s 25ms/step - loss: 7.8716 - mae: 7.8716\n",
            "Epoch 92/100\n",
            "2/2 [==============================] - 0s 19ms/step - loss: 7.9196 - mae: 7.9196\n",
            "Epoch 93/100\n",
            "2/2 [==============================] - 0s 12ms/step - loss: 9.4132 - mae: 9.4132\n",
            "Epoch 94/100\n",
            "2/2 [==============================] - 0s 14ms/step - loss: 8.7349 - mae: 8.7349\n",
            "Epoch 95/100\n",
            "2/2 [==============================] - 0s 7ms/step - loss: 9.8504 - mae: 9.8504\n",
            "Epoch 96/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 7.3487 - mae: 7.3487\n",
            "Epoch 97/100\n",
            "2/2 [==============================] - 0s 14ms/step - loss: 6.8605 - mae: 6.8605\n",
            "Epoch 98/100\n",
            "2/2 [==============================] - 0s 20ms/step - loss: 7.2555 - mae: 7.2555\n",
            "Epoch 99/100\n",
            "2/2 [==============================] - 0s 15ms/step - loss: 7.4059 - mae: 7.4059\n",
            "Epoch 100/100\n",
            "2/2 [==============================] - 0s 11ms/step - loss: 11.1149 - mae: 11.1149\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f5bda8bffa0>"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A-Da56xspOrY",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 616
        },
        "outputId": "6b283c4b-290c-4ec8-f339-d0b5ad3adca7"
      },
      "source": [
        "# Make and plot predictions for model_1\n",
        "y_preds_1 = model_1.predict(X_test)\n",
        "plot_predictions(predictions=y_preds_1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 119ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EXxHBAtHoSh2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bfeadce1-d053-4a70-eeaa-0d1eecc08405"
      },
      "source": [
        "# Calculate model_1 metrics\n",
        "mae_1 = mae(y_test, y_preds_1.squeeze()).numpy()\n",
        "mse_1 = mse(y_test, y_preds_1.squeeze()).numpy()\n",
        "mae_1, mse_1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(21.303345, 457.28232)"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XXELOpdBrE9_"
      },
      "source": [
        "**Build `model_2`**\n",
        "\n",
        "This time we'll add an extra dense layer (so now our model will have 2 layers) whilst keeping everything else the same."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "05vcgEP3rEFi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4876fe5c-d2a3-496e-ca60-654f7f30e1eb"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Replicate model_1 and add an extra layer\n",
        "model_2 = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(1),\n",
        "  tf.keras.layers.Dense(1) # add a second layer\n",
        "])\n",
        "\n",
        "# Compile the model\n",
        "model_2.compile(loss=tf.keras.losses.mae,\n",
        "                optimizer=tf.keras.optimizers.SGD(),\n",
        "                metrics=['mae'])\n",
        "\n",
        "# Fit the model\n",
        "model_2.fit(tf.expand_dims(X_train, axis=-1), y_train, epochs=100, verbose=0) # set verbose to 0 for less output"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f5bc310ae90>"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9xCbDcoDraux",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 656
        },
        "outputId": "1c97b7a6-b3a1-4512-c33a-022a10397a4c"
      },
      "source": [
        "# Make and plot predictions for model_2\n",
        "y_preds_2 = model_2.predict(X_test)\n",
        "plot_predictions(predictions=y_preds_2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:5 out of the last 5 calls to <function Model.make_predict_function.<locals>.predict_function at 0x7f5bc3131090> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 79ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GxMYu5Frri6o"
      },
      "source": [
        "Woah, that's looking better already! And all it took was an extra layer."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9LnPuGaBrcrP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5ae8f9f2-9712-46c9-ac4b-0e3f1b0f446c"
      },
      "source": [
        "# Calculate model_2 metrics\n",
        "mae_2 = mae(y_test, y_preds_2.squeeze()).numpy()\n",
        "mse_2 = mse(y_test, y_preds_2.squeeze()).numpy()\n",
        "mae_2, mse_2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(26.21605, 712.93787)"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R8i9yfQGrwHx"
      },
      "source": [
        "**Build `model_3`**\n",
        "\n",
        "For our 3rd model, we'll keep everything the same as `model_2` except this time we'll train for longer (500 epochs instead of 100).\n",
        "\n",
        "This will give our model more of a chance to learn the patterns in the data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ABGwQFsbrvUS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5727f777-e62f-49ac-d4bd-01693cf060b7"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Replicate model_2\n",
        "model_3 = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(1),\n",
        "  tf.keras.layers.Dense(1)\n",
        "])\n",
        "\n",
        "# Compile the model\n",
        "model_3.compile(loss=tf.keras.losses.mae,\n",
        "                optimizer=tf.keras.optimizers.SGD(),\n",
        "                metrics=['mae'])\n",
        "\n",
        "# Fit the model (this time for 500 epochs, not 100)\n",
        "model_3.fit(tf.expand_dims(X_train, axis=-1), y_train, epochs=500, verbose=0) # set verbose to 0 for less output"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f5bc397b4c0>"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jEz4bVmasbFk",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 654
        },
        "outputId": "2a9482ab-1238-4a8e-c65b-2fe34168c207"
      },
      "source": [
        "# Make and plot predictions for model_3\n",
        "y_preds_3 = model_3.predict(X_test)\n",
        "plot_predictions(predictions=y_preds_3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:6 out of the last 6 calls to <function Model.make_predict_function.<locals>.predict_function at 0x7f5bda9811b0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 46ms/step\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0EAAAJGCAYAAACdj47VAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABjxUlEQVR4nO3dfXyT9bnH8W8aaAWhrSDQ0IQHRYGJj7hxYEbLkQnqtBA7POAUnMNtglLRTTnH+bTt4Hxaq3NTpxbPpk7s7jHmNhygaFRAxmTMrSAwsDUE2FRaRCmQ3ueP22RN05K0zXM+79crr3L/7utOf4lZ16u/331dNtM0TQEAAABAjshL9QQAAAAAIJlIggAAAADkFJIgAAAAADmFJAgAAABATiEJAgAAAJBTSIIAAAAA5BSSIAAAAAA5pUeqJ9BdLS0t2rVrl/r27SubzZbq6QAAAABIEdM0tX//fg0ePFh5eR2v92R8ErRr1y65XK5UTwMAAABAmmhoaJDT6ezwfMYnQX379pVkvdDCwsIUzwYAAABAqjQ1NcnlcoVyhI5kfBIU3AJXWFhIEgQAAAAg6m0yFEYAAAAAkFNIggAAAADkFJIgAAAAADkl4+8JilUgENDhw4dTPQ2ksZ49e8put6d6GgAAAEiwrE+CTNPU7t27tW/fvlRPBRmguLhYJSUl9JwCAADIYlmfBAUToIEDB6p37978cot2maapTz75RHv37pUkORyOFM8IAAAAiZLVSVAgEAglQP3790/1dJDmevXqJUnau3evBg4cyNY4AACALJXVhRGC9wD17t07xTNBpgh+Vrh/DAAAIHtldRIUxBY4xIrPCgAAQPbLiSQIAAAAAIJIgnLEsGHDVFVVFXP86tWrZbPZUlJVb/HixSouLk769wUAAEBuIAlKMzab7aiPO++8s0vPu379el177bUxx0+YMEF+v19FRUVd+n7J1tkkDwAAALkrq6vDxUsgIHm9kt8vORyS2y0lqnCY3+8P/fv555/X7bffri1btoTG+vTpE/q3aZoKBALq0SP6f8YBAwZ0ah75+fkqKSnp1DUAAABAJmAlKArDkIYNkyZOlGbOtL4OG2aNJ0JJSUnoUVRUJJvNFjrevHmz+vbtqz/84Q8aO3asCgoK9Prrr2v79u0qLy/XoEGD1KdPH33+85/XypUrw5637UqJzWbTE088oWnTpql379466aSTtGzZstD5ttvhglvUXnrpJY0ePVp9+vTRlClTwpK2I0eO6IYbblBxcbH69++vW265RbNmzdLUqVOP+poXL16sIUOGqHfv3po2bZo++OCDsPPRXl9ZWZnee+893XjjjaEVM0n64IMPNGPGDJWWlqp379469dRT9dxzz3XmPwcAAACyEEnQURiGVFEhvf9++LjPZ40nKhGK5tZbb9U999yjuro6nXbaafr444910UUXadWqVXr77bc1ZcoUXXLJJaqvrz/q89x1112aPn26Nm3apIsuukhXXHGFPvzwww7jP/nkE91///36+c9/rtdee0319fW6+eabQ+d/+MMf6plnnlFNTY3eeOMNNTU1aenSpUedw7p163TNNddo3rx52rhxoyZOnKjvf//7YTHRXp9hGHI6nbr77rvl9/tDidnBgwc1duxY/e53v9M777yja6+9VldeeaXeeuuto84JAAAAWc7McI2NjaYks7GxMeLcp59+av797383P/30004/75Ejpul0mqbU/sNmM02Xy4pLlJqaGrOoqCh0/Morr5iSzKVLl0a99pRTTjEffvjh0PHQoUPNH/3oR6FjSeZtt90WOv74449NSeYf/vCHsO/10UcfheYiydy2bVvomkceecQcNGhQ6HjQoEHmfffdFzo+cuSIOWTIELO8vLzDec6YMcO86KKLwsYuv/zysNfdldfXkYsvvti86aabOjzfnc8MAAAAUutouUFrrAR1wOuNXAFqzTSlhgYrLtnOPvvssOOPP/5YN998s0aPHq3i4mL16dNHdXV1UVeCTjvttNC/jz32WBUWFmrv3r0dxvfu3Vsnnnhi6NjhcITiGxsbtWfPHn3hC18Inbfb7Ro7duxR51BXV6dx48aFjY0fPz4ury8QCOh73/ueTj31VPXr1099+vTRSy+9FPU6AAAAZDcKI3Sg1a0ucYmLp2OPPTbs+Oabb9aKFSt0//33a8SIEerVq5cqKip06NChoz5Pz549w45tNptaWlo6FW+aZidn33ldfX333XefqqurVVVVpVNPPVXHHnusKisro14HAACA2ARaAvLWe+Xf75ejr0PuIW7Z8xJUQSyOSII64HDENy6R3njjDc2ePVvTpk2TZK2c7Ny5M6lzKCoq0qBBg7R+/Xqde+65kqyVmD//+c8644wzOrxu9OjRWrduXdjY2rVrw45jeX35+fkKBAIR15WXl+urX/2qJKmlpUXvvvuuPve5z3XlJQIAAKAVo87Q/OXz9X7Tv7dPOQudqp5SLc9oTwpnFh3b4TrgdktOp/RZobEINpvkcllxqXbSSSfJMAxt3LhRf/nLXzRz5syjrugkyvXXX69FixbpN7/5jbZs2aL58+fro48+ClVra88NN9yg5cuX6/7779fWrVv14x//WMuXLw+LieX1DRs2TK+99pp8Pp/+9a9/ha5bsWKF3nzzTdXV1ekb3/iG9uzZE/8XDgAAkGOMOkMVSyrCEiBJ8jX5VLGkQkZdiiqIxYgkqAN2u1Rdbf277e/wweOqqsT1C+qMBx98UMcdd5wmTJigSy65RJMnT9ZZZ52V9HnccsstmjFjhq666iqNHz9effr00eTJk3XMMcd0eM1//Md/6Gc/+5mqq6t1+umn649//KNuu+22sJhYXt/dd9+tnTt36sQTTwz1RLrtttt01llnafLkySorK1NJSUnUct0AAAA4ukBLQPOXz5epyNsigmOVyysVaAlEnE8XNjMZN3UkUFNTk4qKitTY2KjCwsKwcwcPHtSOHTs0fPjwo/4ifjSGIc2fH14kweWyEiBPeq/ypVxLS4tGjx6t6dOn63vf+16qpxOTeHxmAAAAstnqnas18emJUeNemfWKyoaVJX5CrRwtN2iNe4Ki8Hik8nKrCpzfb90D5HanxwpQunnvvff0xz/+Ueedd56am5v14x//WDt27NDMmTNTPTUAAADEiX9/bJXBYo1LBZKgGNjtUllZqmeR/vLy8rR48WLdfPPNMk1TY8aM0cqVKzV69OhUTw0AAABx4ugbW2WwWONSgSQIceNyufTGG2+kehoAAABIIPcQt5yFTvmafO3eF2STTc5Cp9xD0qCCWAcojAAAAAAgZvY8u6qnWBXEbAqvIBY8rppSldb9gkiCAAAAAHSKZ7RHtdNrVVpYGjbuLHSqdnpt2vcJYjscAAAAkMMCLQF5673y7/fL0dch9xB3TKs4ntEelY8s79K1qUYSBAAAAOQoo87Q/OXzw5qeOgudqp5SHdNqjj3PnvQy2PHAdjgAAAAgBxl1hiqWVIQlQJLka/KpYkmFjDojRTNLPJIgAAAAIMcEWgKav3x+u9XdgmOVyysVaAkke2pJQRKU4+68806dccYZKfnes2fP1tSpU1PyvQEAAHKZt94bsQLUmilTDU0N8tZ7kzir5CEJSjM2m+2ojzvvvLNbz7106dKwsZtvvlmrVq3q3qSTZOfOnbLZbNq4cWOqpwIAAJDR/Pv9cY3LNF1Ogl577TVdcsklGjx4cLu/XJumqdtvv10Oh0O9evXSpEmTtHXr1rCYDz/8UFdccYUKCwtVXFysa665Rh9//HFXp5QwgZaAVu9cref++pxW71yd0GVBv98felRVVamwsDBs7Oabb47r9+vTp4/69+8f1+cEAABAenP0dcQ1LtN0OQk6cOCATj/9dD3yyCPtnr/33nv10EMP6dFHH9W6det07LHHavLkyTp48GAo5oorrtDf/vY3rVixQi+++KJee+01XXvttV2dUkIYdYaGVQ/TxKcnaqYxUxOfnqhh1cMSdqNYSUlJ6FFUVCSbzRY29stf/lKjR4/WMccco1GjRuknP/lJ6NpDhw5p3rx5cjgcOuaYYzR06FAtWrRIkjRs2DBJ0rRp02Sz2ULHbbfDBbeo3X///XI4HOrfv7/mzp2rw4cPh2L8fr8uvvhi9erVS8OHD9ezzz6rYcOGqaqqqsPXFQgEtGDBAhUXF6t///76zne+I9MM34O6fPlynXPOOaGYL3/5y9q+fXvo/PDhwyVJZ555pmw2m8rKyiRJ69ev15e+9CUdf/zxKioq0nnnnac///nPnX3rAQAAcoZ7iFvOQmdEs9Mgm2xyFbrkHuJO8sySo8tJ0IUXXqjvf//7mjZtWsQ50zRVVVWl2267TeXl5TrttNP0f//3f9q1a1doxaiurk7Lly/XE088oXHjxumcc87Rww8/rF/+8pfatWtXl19QPKVbxYxnnnlGt99+u37wgx+orq5O//u//6vvfve7evrppyVJDz30kJYtW6YlS5Zoy5YteuaZZ0LJzvr16yVJNTU18vv9oeP2vPLKK9q+fbteeeUVPf3001q8eLEWL14cOn/VVVdp165dWr16tX71q1/p8ccf1969e4869wceeECLFy/WU089pddff10ffvihfv3rX4fFHDhwQAsWLNCf/vQnrVq1Snl5eZo2bZpaWlokSW+99ZYkaeXKlfL7/TIM6/3fv3+/Zs2apddff11r167VSSedpIsuukj79++P/c0FAADIIfY8u6qnVEtSRCIUPK6aUpURPX+6IiF9gnbs2KHdu3dr0qRJobGioiKNGzdOa9as0X/9139pzZo1Ki4u1tlnnx2KmTRpkvLy8rRu3bp2kytJam5uVnNzc+i4qakpES8hasUMm2yqXF6p8pHlSftw3HHHHXrggQfk8Vg124cPH66///3veuyxxzRr1izV19frpJNO0jnnnCObzaahQ4eGrh0wYIAkqbi4WCUlJUf9Pscdd5x+/OMfy263a9SoUbr44ou1atUqzZkzR5s3b9bKlSu1fv360H+7J554QieddNJRn7OqqkoLFy4Mzf3RRx/VSy+9FBZz2WWXhR0/9dRTGjBggP7+979rzJgxodfQv3//sNfwn//5n2HXPf744youLtarr76qL3/5y0edFwAAQK7yjPaodnptu32CqqZUxdQnKFMlJAnavXu3JGnQoEFh44MGDQqd2717twYOHBg+mR491K9fv1BMexYtWqS77rorzjOO1JmKGcloEHXgwAFt375d11xzjebMmRMaP3LkiIqKiiRZW9m+9KUvaeTIkZoyZYq+/OUv64ILLuj09zrllFNkt/87sXM4HPrrX/8qSdqyZYt69Oihs846K3R+xIgROu644zp8vsbGRvn9fo0bNy401qNHD5199tlhW+K2bt2q22+/XevWrdO//vWv0ApQfX29xowZ0+Hz79mzR7fddptWr16tvXv3KhAI6JNPPlF9fX2nXzsAAECmCrQE5K33yr/fL0dfh9xD3FH/WO8Z7VH5yPJOX5fpEpIEJdLChQu1YMGC0HFTU5NcLlfcv0+6VcwIFoz42c9+FpZMSAolLGeddZZ27NihP/zhD1q5cqWmT5+uSZMmqba2tlPfq2fPnmHHNpstlJAk0iWXXKKhQ4fqZz/7mQYPHqyWlhaNGTNGhw4dOup1s2bN0gcffKDq6moNHTpUBQUFGj9+fNTrAAAAsoVRZ7S7olM9pTrqio49z56UP+qnk4SUyA5uVdqzZ0/Y+J49e0LnSkpKIu4jOXLkiD788MOjbtcqKChQYWFh2CMR0q1ixqBBgzR48GD94x//0IgRI8IewYIBklRYWKjLL79cP/vZz/T888/rV7/6lT788ENJVnITCHSvst3IkSN15MgRvf3226Gxbdu26aOPPurwmqKiIjkcDq1bty40duTIEW3YsCF0/MEHH2jLli267bbbdP7552v06NERz5mfny9JEa/hjTfe0A033KCLLrpIp5xyigoKCvSvf/2rW68TAAAgU6TbfeyZICFJ0PDhw1VSUhLWf6apqUnr1q3T+PHjJUnjx4/Xvn37wn4Rfvnll9XS0hKx0pEK6Vgx46677tKiRYv00EMP6d1339Vf//pX1dTU6MEHH5QkPfjgg3ruuee0efNmvfvuu3rhhRdUUlKi4uJiSVaFuFWrVmn37t1HTVqOZtSoUZo0aZKuvfZavfXWW3r77bd17bXXqlevXrLZ2n+vJGn+/Pm65557tHTpUm3evFnXXXed9u3bFzp/3HHHqX///nr88ce1bds2vfzyy2ErfpI0cOBA9erVS8uXL9eePXvU2NgoSTrppJP085//XHV1dVq3bp2uuOIK9erVq0uvDwAAIJNEu49dkiqXVya0xUsm6nIS9PHHH2vjxo2hxpU7duzQxo0bVV9fL5vNpsrKSn3/+9/XsmXL9Ne//lVXXXWVBg8erKlTp0qSRo8erSlTpmjOnDl666239MYbb2jevHn6r//6Lw0ePDger61b0rFixte//nU98cQTqqmp0amnnqrzzjtPixcvDq0E9e3bV/fee6/OPvtsff7zn9fOnTv1+9//Xnl51n/mBx54QCtWrJDL5dKZZ57Z5Xn83//9nwYNGqRzzz1X06ZN05w5c9S3b18dc8wxHV5z00036corr9SsWbM0fvx49e3bN6z4RV5enn75y19qw4YNGjNmjG688Ubdd999Yc/Ro0cPPfTQQ3rsscc0ePBglZeXS5KefPJJffTRRzrrrLN05ZVX6oYbboi43wwAACAbdeY+dvybzWzbrCVGq1ev1sSJEyPGZ82apcWLF8s0Td1xxx16/PHHtW/fPp1zzjn6yU9+opNPPjkU++GHH2revHn67W9/q7y8PF122WV66KGH1KdPn5jn0dTUpKKiIjU2NkZsjTt48KB27Nih4cOHH/UX9KNpb3+lq9CV9RUzOuP999+Xy+XSypUrdf7556d6Ot0Sj88MAABAsjz31+c005gZNe5Zz7OaceqMJMwotY6WG7TW5SQoXSQ6CZK6Vmkjm7388sv6+OOPdeqpp8rv9+s73/mOfD6f3n333YiiCpmGJAgAAGSS1TtXa+LTkQsTbb0y65WcKH4QaxKUcdXhUiEXK2YczeHDh/Xf//3f+sc//qG+fftqwoQJeuaZZzI+AQIAAMg0wfvYfU2+du8LsskmZ6EzqfexZwKSIHTa5MmTNXny5FRPAwAAIOcF72OvWFIhm2xhiVCq7mPPBAmpDgcAAAAgOTyjPaqdXqvSwtKwcWehU7XTa7mPvR2sBAEAAABpoqv3ontGe1Q+spz72GNEEgQAAACkgfaqEjsLnaqeUh3Tag73sceO7XAAAABAihl1hiqWVET0/PE1+VSxpEJGnZGimWUnkiAAAAAghQItAc1fPr/d6m7BscrllQq0BJI9taxFEgQAAACkkLfeG7EC1JopUw1NDfLWe5M4q+xGEpTjZs+eralTp4aOy8rKVFlZ2a3njMdzAAAA5Ar/fn9c4xAdSVCamj17tmw2m2w2m/Lz8zVixAjdfffdOnLkSEK/r2EY+t73vhdT7OrVq2Wz2bRv374uPwcAAECuc/R1xDUO0VEdLhaBgOT1Sn6/5HBIbrdkT3y5wSlTpqimpkbNzc36/e9/r7lz56pnz55auHBhWNyhQ4eUn58fl+/Zr1+/tHgOAACAXOEe4paz0Clfk6/d+4JssslZ6JR7iDsFs8tOrARFYxjSsGHSxInSzJnW12HDrPEEKygoUElJiYYOHapvfetbmjRpkpYtWxbawvaDH/xAgwcP1siRIyVJDQ0Nmj59uoqLi9WvXz+Vl5dr586doecLBAJasGCBiouL1b9/f33nO9+RaYb/D63tVrbm5mbdcsstcrlcKigo0IgRI/Tkk09q586dmjhxoiTpuOOOk81m0+zZs9t9jo8++khXXXWVjjvuOPXu3VsXXnihtm7dGjq/ePFiFRcX66WXXtLo0aPVp08fTZkyRX7/v5d8V69erS984Qs69thjVVxcrC9+8Yt677334vROAwAApI49z67qKdWSrISnteBx1ZQqev7EEUnQ0RiGVFEhvd/mRjWfzxpPQiLUWq9evXTo0CFJ0qpVq7RlyxatWLFCL774og4fPqzJkyerb9++8nq9euONN0LJRPCaBx54QIsXL9ZTTz2l119/XR9++KF+/etfH/V7XnXVVXruuef00EMPqa6uTo899pj69Okjl8ulX/3qV5KkLVu2yO/3q7q6ut3nmD17tv70pz9p2bJlWrNmjUzT1EUXXaTDhw+HYj755BPdf//9+vnPf67XXntN9fX1uvnmmyVJR44c0dSpU3Xeeedp06ZNWrNmja699lrZbLZ2vx8AAECm8Yz2qHZ6rUoLS8PGnYVO1U6vjalPEGLHdriOBALS/PmSGbkkKdOUbDapslIqL0/41jjTNLVq1Sq99NJLuv766/XPf/5Txx57rJ544onQNrhf/OIXamlp0RNPPBFKDmpqalRcXKzVq1frggsuUFVVlRYuXCiPx/of0aOPPqqXXnqpw+/77rvvasmSJVqxYoUmTZokSTrhhBNC54Pb3gYOHKji4uJ2n2Pr1q1atmyZ3njjDU2YMEGS9Mwzz8jlcmnp0qX6yle+Ikk6fPiwHn30UZ144omSpHnz5unuu++WJDU1NamxsVFf/vKXQ+dHjx7d+TcSAAAgSQItAXnrvfLv98vR1yH3EHfUlRzPaI/KR5Z3+jp0HklQR7zeyBWg1kxTamiw4srKEjKFF198UX369NHhw4fV0tKimTNn6s4779TcuXN16qmnht0H9Je//EXbtm1T3759w57j4MGD2r59uxobG+X3+zVu3LjQuR49eujss8+O2BIXtHHjRtntdp133nldfg11dXXq0aNH2Pft37+/Ro4cqbq6utBY7969QwmOJDkcDu3du1eSlWzNnj1bkydP1pe+9CVNmjRJ06dPl8PBzYEAACD9GHWG5i+fH1b22lnoVPWU6qgrOvY8u8qGlSV4hmA7XEf8MZYgjDWuCyZOnKiNGzdq69at+vTTT/X000/r2GOPlaTQ16CPP/5YY8eO1caNG8Me7777rmbOnNml79+rV69uv4ZY9ezZM+zYZrOFJWc1NTVas2aNJkyYoOeff14nn3yy1q5dm7T5AQAAxMKoM1SxpCKi74+vyaeKJRUy6pJ7OwXaRxLUkVhXGRK4GnHsscdqxIgRGjJkiHr0OPqi3VlnnaWtW7dq4MCBGjFiRNijqKhIRUVFcjgcWrduXeiaI0eOaMOGDR0+56mnnqqWlha9+uqr7Z4PrkQFAh13Lx49erSOHDkS9n0/+OADbdmyRZ/73OeO+praOvPMM7Vw4UK9+eabGjNmjJ599tlOXQ8AAJBIgZaA5i+f326Ft+BY5fJKBVo6/t0JyUES1BG3W3I6rXt/2mOzSS6XFZcGrrjiCh1//PEqLy+X1+vVjh07tHr1at1www16/7NtffPnz9c999yjpUuXavPmzbruuusievy0NmzYMM2aNUtf+9rXtHTp0tBzLlmyRJI0dOhQ2Ww2vfjii/rnP/+pjz/+OOI5TjrpJJWXl2vOnDl6/fXX9Ze//EVf/epXVVpaqvLy8phe244dO7Rw4UKtWbNG7733nv74xz9q69at3BcEAADSirfeG7EC1JopUw1NDfLWe5M4K7SHJKgjdrsUrHbWNhEKHldVJaVfUCx69+6t1157TUOGDJHH49Ho0aN1zTXX6ODBgyosLJQk3XTTTbryyis1a9YsjR8/Xn379tW0adOO+rw//elPVVFRoeuuu06jRo3SnDlzdODAAUlSaWmp7rrrLt16660aNGiQ5s2b1+5z1NTUaOzYsfryl7+s8ePHyzRN/f73v4/YAne017Z582ZddtllOvnkk3Xttddq7ty5+sY3vtGJdwgAACCx/Ptju00i1jgkjs3s6K74DNHU1KSioiI1NjaGftkPOnjwoHbs2KHhw4frmGOO6do3MAyrSlzrIgkul5UAeShVmG3i8pkBAAA5afXO1Zr49MSoca/MeoXiBwlytNygNarDRePxWGWwvV6rCILDYW2BS5MVIAAAAKQH9xC3nIVO+Zp87d4XZJNNzkKn3EPS43aKXEYSFAu7PWFlsAEAAJAd7Hl2VU+pVsWSCtlkC0uEbLJup6iaUkXfnzTAPUEAAABAnHhGe1Q7vValhaVh485Cp2qn10btE4TkYCUIAAAA6ECgJSBvvVf+/X45+jrkHuKOupLjGe1R+cjyTl+H5MmJJCjDaz8gifisAACAIKPO0Pzl88PKXjsLnaqeUh11RceeZ6f4QRrL6u1wwRLMn3zySYpngkwR/KzEWr4bAABkJ6POUMWSioi+P74mnyqWVMioM1I0M8RDVq8E2e12FRcXa+/evZKsfjO2jpqfIqeZpqlPPvlEe/fuVXFxsexU/wMAIGcFWgKav3x+uxXeTJmyyabK5ZUqH1nOFrcMldVJkCSVlJRIUigRAo6muLg49JkBAAC5yVvvjVgBas2UqYamBnnrvWx5y1BZnwTZbDY5HA4NHDhQhw8fTvV0kMZ69uzJChAAAJB/vz+ucUg/WZ8EBdntdn7BBQAAQFSOvo64xiH9ZHVhBAAAAKCz3EPcchY6Qw1O27LJJlehS+4h7iTPDPFCEgQAAAC0Ys+zq3pKtSRFJELB46opVRRFyGAkQQAAAEAbntEe1U6vVWlhadi4s9Cp2um1UfsEIb3ZzAzvDtnU1KSioiI1NjaqsLAw1dMBAABAmgm0BOSt98q/3y9HX4fcQ9wxr+J051okX6y5Qc4URgAAAEDuMeoMzV8+P6zktbPQqeop1TGt5tjz7JTBzkJshwMAAEBWMuoMVSypiOj542vyqWJJhYw6I0UzQ6qRBAEAACDrBFoCmr98vkxF3vkRHKtcXqlASyDZU0MaIAkCAABA1vHWeyNWgFozZaqhqUHeem8SZ4V0QRIEAACArOPf749rHLILSRAAAACyjqOvI65xyC4kQQAAAMg67iFuOQudEc1Og2yyyVXoknuIO8kzQzogCQIAAEDWsefZVT2lWpIiEqHgcdWUKnr+5CiSIAAAAGQlz2iPaqfXqrSwNGzcWehU7fTamPoEITvZTNOMrBuYQWLtCgsAAIDMFmgJyFvvlX+/X46+DrmHuGNayenqdcg8seYGPZI4JwAAAKBLjDpD85fPDyt77Sx0qnpKddQVHXueXWXDyhI8Q2QStsMBAAAgrRl1hiqWVET0/fE1+VSxpEJGnZGimSFTkQQBAAAgbQVaApq/fL5MRd7BERyrXF6pQEsg2VNDBiMJAgAAQNry1nsjVoBaM2WqoalB3npvEmeFTEcSBAAAgLTl3++PaxwgkQQBAAAgjTn6OuIaB0gkQQAAAEhj7iFuOQudEQ1Pg2yyyVXoknuIO8kzQyZLaBI0bNgw2Wy2iMfcuXMlSWVlZRHnvvnNbyZySgAAAMgg9jy7qqdUS1JEIhQ8rppSRd8fdEpCk6D169fL7/eHHitWrJAkfeUrXwnFzJkzJyzm3nvvTeSUAAAAkGE8oz2qnV6r0sLSsHFnoVO102uj9gkC2kpos9QBAwaEHd9zzz068cQTdd5554XGevfurZKSkkROAwAAAGkk0BKQt94r/36/HH0dcg9xR13J8Yz2qHxkeaevA9qT0CSotUOHDukXv/iFFixYIJvt30uZzzzzjH7xi1+opKREl1xyib773e+qd+/eHT5Pc3OzmpubQ8dNTU0JnTcAAADix6gzNH/5/LCy185Cp6qnVEdd0bHn2VU2rCzBM0QuSFoStHTpUu3bt0+zZ88Ojc2cOVNDhw7V4MGDtWnTJt1yyy3asmWLDKPjrr+LFi3SXXfdlYQZAwAAIJ6MOkMVSyoiGp/6mnyqWFLB1jYkjc00zcj2uwkwefJk5efn67e//W2HMS+//LLOP/98bdu2TSeeeGK7Me2tBLlcLjU2NqqwsDDu8wYAAED3BVoCGlY9rMPGpzbZ5Cx0asf8HWxxQ5c1NTWpqKgoam6QlBLZ7733nlauXKmvf/3rR40bN26cJGnbtm0dxhQUFKiwsDDsAQAAgPTmrfd2mABJkilTDU0N8tZ7kzgr5KqkJEE1NTUaOHCgLr744qPGbdy4UZLkcNDsCgAAIJv49/vjGgd0R8LvCWppaVFNTY1mzZqlHj3+/e22b9+uZ599VhdddJH69++vTZs26cYbb9S5556r0047LdHTAgAAQBI5+sb2R+5Y44DuSHgStHLlStXX1+trX/ta2Hh+fr5WrlypqqoqHThwQC6XS5dddpluu+22RE8JAAAASeYe4paz0Clfky+iMIL073uC3EPcKZgdck3SCiMkSqw3PwEAACC1gtXhJIUlQjZZ7VOoDofuSqvCCAAAAIBntEe102tVWlgaNu4sdJIAIalYCQIAAECnBVoC8tZ75d/vl6OvQ+4h7phLW3fnWuBoYs0NktYsFQAAANnBqDM0f/n8sJLXzkKnqqdUx7SaY8+zq2xYWQJnCBwd2+EAAAAQs+B9PW17/viafKpYUiGjzkjRzIDYkQQBAAAgJoGWgOYvn99udbfgWOXySgVaAsmeGtApJEEAAACIibfeG7EC1JopUw1NDfLWe5M4K6DzSIIAAAAQE/9+f1zjgFQhCQIAAEBMHH0dcY0DUoUkCAAAADFxD3HLWegMNTdtyyabXIUuuYe4kzwzoHNIggAAABATe55d1VOqJSkiEQoeV02poucP0h5JEAAAAGLmGe1R7fRalRaWho07C52qnV4bU58gINVspmlG1jjMILF2hQUAAECkQEDyeiW/X3I4JLdbssewkBNoCchb75V/v1+Ovg65h7hZAULKxZob9EjinAAAAJBGDEOaP196v1XVa6dTqq6WPFEWdOx5dpUNK0vo/IBEYTscAABADjIMqaIiPAGSJJ/PGjeM1MwLSAaSIAAAgBwTCFgrQO3dFBEcq6y04oBsRBIEAACQY7zeyBWg1kxTamiw4oBsRBIEAACQY/z++MYBmYYkCAAAIMc4HPGNAzINSRAAAECOcbutKnA2W/vnbTbJ5bLigGxEEgQAAJBj7HarDLYUmQgFj6uqYusXBGQikiAAAIAc5PFItbVSaWn4uNNpjUfrEwRkMpqlAgAAZLhAwKrk5vdb9/G43bGt4ng8Unl5164FMhlJEAAAQAYzDKvnT+uS106ntd0tltUcu10qK0vY9IC0xHY4AACADGUYUkVFZM8fn88aN4zUzAtIdyRBAAAAGSgQsFaATDPyXHCsstKKAxCOJAgAACADeb2RK0CtmabU0GDFAQhHEgQAAJCB/P74xgG5hCQIAAAgAzkc8Y0DcglJEAAAQAZyu60qcG2bnQbZbJLLZcUBCEcSBAAAkIHsdqsMthSZCAWPq6ro+QO0hyQIAAAgQ3k8Um2tVFoaPu50WuOx9AkCchHNUgEAANJEIGBVc/P7rXt53O7oKzkej1Re3vnrgFxGEgQAAJAGDMPq+9O67LXTaW15i7aiY7dLZWUJnR6QVdgOBwAAkGKGIVVURPb98fmsccNIzbyAbEUSBAAAkEKBgLUCZJqR54JjlZVWHID4IAkCAABIIa83cgWoNdOUGhqsOADxQRIEAACQQn5/fOMAREcSBAAAkEIOR3zjAERHEgQAAJBCbrdVBa5tw9Mgm01yuaw4APFBEgQAAJBCdrtVBluKTISCx1VV9P0B4okkCAAAIMU8Hqm2ViotDR93Oq3xaH2CAHQOzVIBAADiLBCwqrn5/da9PG539JUcj0cqL+/8dQA6jyQIAAAgjgzD6vvTuuy102lteYu2omO3S2VlCZ0eALEdDgAAIG4MQ6qoiOz74/NZ44aRmnkBCEcSBAAAEAeBgLUCZJqR54JjlZVWHIDUIgkCAACIA683cgWoNdOUGhqsOACpRRIEAAAQB35/fOMAJA5JEAAAQBw4HPGNA5A4JEEAAABx4HZbVeDaNjwNstkkl8uKA5BaJEEAAABxYLdbZbClyEQoeFxVRd8fIB2QBAEAAMSJxyPV1kqlpeHjTqc1Hq1PEIDkoFkqAABAOwIBq5Kb32/dx+N2x7aK4/FI5eVduxZAciR0JejOO++UzWYLe4waNSp0/uDBg5o7d6769++vPn366LLLLtOePXsSOSUAAICoDEMaNkyaOFGaOdP6OmxY7M1O7XaprEyaMcP6SgIEpJeEb4c75ZRT5Pf7Q4/XX389dO7GG2/Ub3/7W73wwgt69dVXtWvXLnlYJwYAAClkGFJFRWTPH5/PGo81EQKQvhK+Ha5Hjx4qKSmJGG9sbNSTTz6pZ599Vv/5n/8pSaqpqdHo0aO1du1a/cd//EeipwYAABAmEJDmz7cam7ZlmlaBg8pKa7sbqztA5kr4StDWrVs1ePBgnXDCCbriiitUX18vSdqwYYMOHz6sSZMmhWJHjRqlIUOGaM2aNR0+X3Nzs5qamsIeAAAA8eD1Rq4AtWaaUkODFQcgcyU0CRo3bpwWL16s5cuX66c//al27Nght9ut/fv3a/fu3crPz1dxcXHYNYMGDdLu3bs7fM5FixapqKgo9HC5XIl8CQAAIIf4/fGNA5CeErod7sILLwz9+7TTTtO4ceM0dOhQLVmyRL169erScy5cuFALFiwIHTc1NZEIAQCAuHA44hsHID0ltU9QcXGxTj75ZG3btk0lJSU6dOiQ9u3bFxazZ8+edu8hCiooKFBhYWHYAwAAIB7cbqunT9tmp0E2m+RyWXEAMldSk6CPP/5Y27dvl8Ph0NixY9WzZ0+tWrUqdH7Lli2qr6/X+PHjkzktAAAASVaxg+pq699tE6HgcVUVRRGATJfQJOjmm2/Wq6++qp07d+rNN9/UtGnTZLfbNWPGDBUVFemaa67RggUL9Morr2jDhg26+uqrNX78eCrDAQCAlPF4pNpaqbQ0fNzptMbp5gFkvoTeE/T+++9rxowZ+uCDDzRgwACdc845Wrt2rQYMGCBJ+tGPfqS8vDxddtllam5u1uTJk/WTn/wkkVMCAAA5JhCwqrn5/da9PG539JUcj8cqg93Z6wBkBptptlcJP3M0NTWpqKhIjY2N3B8EAADCGIbV96d12Wun09ryxooOkH1izQ2Sek8QAABAshiGVFER2ffH57PGDSM18wKQeiRBAAAg6wQC1gpQe/tdgmOVlVYcgNxDEgQAALKO1xu5AtSaaUoNDVYcgNxDEgQAALKO3x/fOADZhSQIAABkHYcjvnEAsgtJEAAAyDput1UFrm3D0yCbTXK5rDgAuYckCAAAZB273SqDLUUmQsHjqir6/gC5iiQIAABkJY9Hqq2VSkvDx51Oa5w+QUDu6pHqCQAAAMQiELCqufn91r08bnf0lRyPRyov7/x1ALIbSRAAAEh7hmH1/Wld9trptLa8RVvRsdulsrKETg9AhmE7HAAASGuGIVVURPb98fmsccNIzbwAZC6SIAAAkLYCAWsFyDQjzwXHKiutOACIFUkQAABIW15v5ApQa6YpNTRYcQAQK5IgAACQtvz++MYBgEQSBAAA0pjDEd84AJBIggAAQBpzu60qcG0bngbZbJLLZcUBQKxIggAAQNqy260y2FJkIhQ8rqqi7w+AziEJAgAAac3jkWprpdLS8HGn0xqP1icIANqiWSoAAEiaQMCq5Ob3W/fxuN2xreJ4PFJ5edeuBYC2SIIAAEBSGIbV86d1yWun09ruFstqjt0ulZUlbHoAcgjb4QAAQMIZhlRREdnzx+ezxg0jNfMCkJtIggAAQEIFAtYKkGlGnguOVVZacQCQDCRBAAAgobzeyBWg1kxTamiw4gAgGUiCAABAQvn98Y0DgO4iCQIAAAnlcMQ3DgC6iyQIAAAklNttVYFr2+w0yGaTXC4rDgCSgSQIAAAklN1ulcGWIhOh4HFVFT1/ACQPSRAAAEg4j0eqrZVKS8PHnU5rPJY+QQAQLzRLBQAAnRYIWNXc/H7rXh63O/pKjscjlZd3/joAiDeSIAAA0CmGYfX9aV322um0trxFW9Gx26WysoRODwCiYjscAACImWFIFRWRfX98PmvcMFIzLwDoDJIgAAAQk0DAWgEyzchzwbHKSisOANIZSRAAAIiJ1xu5AtSaaUoNDVYcAKQzkiAAABATvz++cQCQKiRBAAAgJg5HfOMAIFVIggAAQEzcbqsKXNuGp0E2m+RyWXEAkM5IggAAQEzsdqsMthSZCAWPq6ro+wMg/ZEEAQCAmHk8Um2tVFoaPu50WuPR+gQBQDqgWSoAADkqELAqufn91n08bndsqzgej1Re3rVrASAdkAQBAJCDDMPq+dO65LXTaW13i2U1x26XysoSNj0ASCi2wwEAkGMMQ6qoiOz54/NZ44aRmnkBQLKQBAEAkEMCAWsFyDQjzwXHKiutOADIViRBAADkEK83cgWoNdOUGhqsOADIViRBAADkEL8/vnEAkIlIggAAyCEOR3zjACATkQQBAJBD3G6rClzbZqdBNpvkcllxAJCtSIIAAMghdrtVBluKTISCx1VV9PwBkN1IggAAyDEej1RbK5WWho87ndZ4LH2CACCT0SwVAIAMFwhY1dz8futeHrc7+kqOxyOVl3f+OgDIBiRBAABkMMOw+v60LnvtdFpb3qKt6NjtUllZQqcHAGmJ7XAAAGQow5AqKiL7/vh81rhhpGZeAJDuEpoELVq0SJ///OfVt29fDRw4UFOnTtWWLVvCYsrKymSz2cIe3/zmNxM5LQAAMl4gYK0AmWbkueBYZaUVBwAIl9Ak6NVXX9XcuXO1du1arVixQocPH9YFF1ygAwcOhMXNmTNHfr8/9Lj33nsTOS0AADKe1xu5AtSaaUoNDVYcACBcQu8JWr58edjx4sWLNXDgQG3YsEHnnntuaLx3794qKSlJ5FQAAMgqfn984wAglyT1nqDGxkZJUr9+/cLGn3nmGR1//PEaM2aMFi5cqE8++aTD52hublZTU1PYAwCAXONwxDcOAHJJ0qrDtbS0qLKyUl/84hc1ZsyY0PjMmTM1dOhQDR48WJs2bdItt9yiLVu2yOjgbs5FixbprrvuSta0AQBIS263VQXO52v/viCbzTrvdid/bgCQ7mym2d6Pzvj71re+pT/84Q96/fXX5XQ6O4x7+eWXdf7552vbtm068cQTI843Nzerubk5dNzU1CSXy6XGxkYVFhYmZO4AAKSjYHU4KTwRstmsrzQ+BZBwXWlUlkBNTU0qKiqKmhskZTvcvHnz9OKLL+qVV145agIkSePGjZMkbdu2rd3zBQUFKiwsDHsAAJCLPB4r0SktDR93OkmAACSBYUjDhkkTJ0ozZ1pfhw3LiPr8Cd0OZ5qmrr/+ev3617/W6tWrNXz48KjXbNy4UZLkYBMzACDHdOUPqh6PVF6eVn+IBZBpuvLDJ7gU3XZTWbBRWZr/JSah2+Guu+46Pfvss/rNb36jkSNHhsaLiorUq1cvbd++Xc8++6wuuugi9e/fX5s2bdKNN94op9OpV199NabvEeuSFwAA6cwwrL4/rcteO51SdXVa/x4BINN15YdPIGCt+HRUpz94U+KOHUn/i0ysuUFCkyBbcFNyGzU1NZo9e7YaGhr01a9+Ve+8844OHDggl8uladOm6bbbbos5oSEJAgBkuo7+oMq9PQA6pbMrOl394bN6tbX1LZpXXpHKymKdfVykRRKUDCRBAIBMlsZ/UAWQSTq7otOdHz7PPWfdAxTNs89KM2bE/BLiIa0KIwAAgPZ5vR3/DiJZf6BtaLDiAOSAQMBaaXnuOetrIBD9muCKTtsfJsH7c9orVNCdHz5Z0KiMJAgAgBTy++MbByCDdaXaWiBgrQC1t7krOFZZGZlMdeeHT7BRWQe3vshmk1yutG5URhIEAEAKZcEfVAG0p7MrOl1ZzZG6vqLTnR8+dru1zU6KTISCx1VVab2HlyQIAIAUyoI/qAJoq7MrOl1dzZG6vqLT3R8+Gd6ojCQIAIAUyoI/qALZLRkrOqm4PyceP3w8HmnnTqsK3LPPWl937Ej7BEgiCQIAIOUy/A+qQPrrSrEBKXkrOqm6PyceP3zsdqsM9owZ1tcM+YsNJbIBAIijrjRej8e1ADrQ1U7EXemh09X+Od3tuxOcqxQ+31ibjWXRDx/6BAEAkGRd/V0LQIyS1Qy0qz10uto/J/j9fL72V5FiaRjW3g8gl8va0pZDP4DoEwQAQBJ1tbATgBgls9hAsiuu5fj9OalAEgQAQDd153ctICele7GBVFRcy+H7c1KBJAgAgG7qzu9aQM7JhGIDqVrRYTUnaUiCAADopu78rgVkrK5UXEvmik53moGmckWH1ZykIAkCAKCbuvO7FpCROruaIyV/Rac7iQwrOlmPJAgAgG7qbuN1IKN0tQpIphUbYEUnq5EEAQDQTfEo7ARkhO5UAcnEYgOs6GQtkiAAAOIgHoWdgLTXnSogmVpsgBWdrNQj1RMAACAddaWBuscjlZdnTeN1IFJ3qoAEV3SiNQQ92opOe92IY2kGGkxkgM+QBAEA0EZ7jdedTuuP0fyuhZzWnSogwRWdigor4WmdCMW6osNfGRAnNtNsLxXPHE1NTSoqKlJjY6MKCwtTPR0AQIYL3vPd9v8dg7+jsbUNOS0QsKrARVvN2bGj4+Skvb8yuFyxregAUcSaG5AEAQDwmeDvdx3d8hDL73dA1gv+pUBqfzUnlr8UdGW/KRCDWHMDCiMAAPCZ7tzzDeSMeFQBodgAUox7ggAA+Ex37vkGcgr35yDDkQQBAPCZ7tzzDeQcqoAgg7EdDgCAz3SnJyMAIHOQBAEA8Jnu9mQEAGQGkiAAAFqJxz3fAID0xj1BAICs1pVKvNzzDQDZjSQIAJC12uvJ6HRaW96irehwzzcAZC+2wwEAslKwn2Pbvj8+nzVuGKmZFwAg9UiCAABZJxCwVoBaN7MPCo5VVlpxAIDcQxIEAMg6Xm/kClBrpik1NFhxAIDcQxIEAMg6fn984wAA2YUkCACQdRyO+MYBALILSRAAIOu43VYVuLYNT4NsNsnlsuIAALmHJAgAkHXsdqsMthSZCAWPq6ro+wMAuYokCACQlTweqbZWKi0NH3c6rfFofYIAANmLZqkAgLQXCFiV3Px+6z4etzu2VRyPRyov79q1AIDsRRIEAEhrhmH1/Gld8trptLa7xbKaY7dLZWUJmx4AIAOxHQ4AkLYMQ6qoiOz54/NZ44aRmnkBADIbSRAAIC0FAtYKkGlGnguOVVZacQAAdAZJEAAgLXm9kStArZmm1NBgxQEA0BkkQQCAtOT3xzcOAIAgkiAAQFpyOOIbBwBAEEkQACAtud1WFbi2zU6DbDbJ5bLiAADoDJIgAEBastutMthSZCIUPK6qoucPAKDzSIIAAGnL45Fqa6XS0vBxp9Maj6VPEAAAbdEsFQCQNIGAVc3N77fu5XG7o6/keDxSeXnnrwMAoCMkQQCApDAMq+9P67LXTqe15S3aio7dLpWVJXR6AIAcwnY4AEDCGYZUURHZ98fns8YNIzXzAgDkJpIgAEBCBQLWCpBpRp4LjlVWWnEAACQDSRAAIKG83sgVoNZMU2posOIAAEgGkiAAQEL5/fGNAwCgu9IiCXrkkUc0bNgwHXPMMRo3bpzeeuutVE8JABAnDkd84wAA6K6UJ0HPP/+8FixYoDvuuEN//vOfdfrpp2vy5Mnau3dvqqcGAIgDt9uqAte24WmQzSa5XFYcAADJkPIk6MEHH9ScOXN09dVX63Of+5weffRR9e7dW0899VSqpwYAiAO73SqDLUUmQsHjqir6/gAAkielSdChQ4e0YcMGTZo0KTSWl5enSZMmac2aNe1e09zcrKamprAHACC9eTxSba1UWho+7nRa49H6BAEAEE8pbZb6r3/9S4FAQIMGDQobHzRokDZv3tzuNYsWLdJdd92VjOkBANoRCFiV3Px+6z4etzu2VRyPRyov79q1AADEU0qToK5YuHChFixYEDpuamqSy+VK4YwAIHcYhtXzp3XJa6fT2u4Wy2qO3S6VlSVsegAAxCSlSdDxxx8vu92uPXv2hI3v2bNHJSUl7V5TUFCggoKCZEwPANCKYUgVFZFNT30+a5xtbQCATJHSe4Ly8/M1duxYrVq1KjTW0tKiVatWafz48SmcGQCgtUDAWgFqmwBJ/x6rrLTiAABIdymvDrdgwQL97Gc/09NPP626ujp961vf0oEDB3T11VenemoAgM94veFb4NoyTamhwYoDACDdpfyeoMsvv1z//Oc/dfvtt2v37t0644wztHz58ohiCQCA1PH74xsHAEAqpTwJkqR58+Zp3rx5qZ4GAKADDkd84wAASKWUb4cDAKQ/t9uqAte22WmQzSa5XFYcAADpjiQIABCV3W6VwZYiE6HgcVUVPX8AAJmBJAgAEBOPxyqDXVoaPu50Uh4bAJBZ0uKeIABA8gUCVjU3v9+6l8ftjr6S4/FI5eWdvw4AgHRCEgQAOcgwrL4/rcteO53WlrdoKzp2u1RWltDpAQCQUGyHA4AcYxhSRUVk3x+fzxo3jNTMCwCAZCEJAoAcEghYK0CmGXkuOFZZacUBAJCtSIIAIId4vZErQK2ZptTQYMUBAJCtSIIAIIf4/fGNAwAgE5EEAUAOcTjiGwcAQCYiCQKAHOJ2W1Xg2jY8DbLZJJfLigMAIFuRBAFADrHbrTLYUmQiFDyuqqLvDwAgu5EEAUCO8Xik2lqptDR83Om0xqP1CQIAINPRLBUAMlwgYFVz8/ute3nc7ugrOR6PVF7e+esAAMgGJEEAkMEMw+r707rstdNpbXmLtqJjt0tlZQmdHgAAaYntcACQoQxDqqiI7Pvj81njhpGaeQEAkO5IggAgAwUC1gqQaUaeC45VVlpxAAAgHEkQAGQgrzdyBag105QaGqw4AAAQjiQIADKQ3x/fOAAAcglJEABkIIcjvnEAAOQSkiAAyEBut1UFrm3D0yCbTXK5rDgAABCOJAgAMpDdbpXBliIToeBxVRV9fwAAaA9JEABkKI9Hqq2VSkvDx51OazxanyAAAHIVzVIBIA0EAlYlN7/fuo/H7Y5tFcfjkcrLu3YtAAC5iiQIAFLMMKyeP61LXjud1na3WFZz7HaprCxh0wMAIOuwHQ4AUsgwpIqKyJ4/Pp81bhipmRcAANmMJAgAUiQQsFaATDPyXHCsstKKAwAA8UMSBAAp4vVGrgC1ZppSQ4MVBwAA4ockCABSxO+PbxwAAIgNSRAApIjDEd84AAAQG5IgAEgRt9uqAte22WmQzSa5XFYcAACIH5IgAEgRu90qgy1FJkLB46oqev4AABBvJEEAkEIej1RbK5WWho87ndZ4LH2CAABA59AsFQDiKBCwqrn5/da9PG539JUcj0cqL+/8dQAAoGtIggAgTgzD6vvTuuy102lteYu2omO3S2VlCZ0eAAD4DNvhACAODEOqqIjs++PzWeOGkZp5AQCASCRBANBNgYC1AmSakeeCY5WVVhwAAEg9kiAA6CavN3IFqDXTlBoarDgAAJB6JEEA0E1+f3zjAABAYpEEAUA3ORzxjQMAAIlFEgQA3eR2W1Xg2jY8DbLZJJfLigMAAKlHEgQA3WS3W2WwpchEKHhcVUXfHwAA0gVJEADEgccj1dZKpaXh406nNR6tTxAAAEgemqUCQDsCAauam99v3cvjdkdfyfF4pPLyzl8HAACSiyQIANowDKvvT+uy106nteUt2oqO3S6VlSV0egAAoJvYDgcArRiGVFER2ffH57PGDSM18wIAAPFDEgQAnwkErBUg04w8FxyrrLTiAABA5iIJAoDPeL2RK0CtmabU0GDFAQCAzEUSBACf8fvjGwcAANITSRAAfMbhiG8cAABITyRBAPAZt9uqAte24WmQzSa5XFYcAADIXAlJgnbu3KlrrrlGw4cPV69evXTiiSfqjjvu0KFDh8JibDZbxGPt2rWJmBIARGW3W2WwpchEKHhcVUXfHwAAMl1C+gRt3rxZLS0teuyxxzRixAi98847mjNnjg4cOKD7778/LHblypU65ZRTQsf9+/dPxJQAICYej1Rb236foKqq6H2CAABA+rOZZnvFYOPvvvvu009/+lP94x//kGStBA0fPlxvv/22zjjjjC4/b1NTk4qKitTY2KjCwsI4zRZANggErEpufr91H4/bHfsqTneuBQAAqRFrbpCQlaD2NDY2ql+/fhHjl156qQ4ePKiTTz5Z3/nOd3TppZce9Xmam5vV3NwcOm5qaor7XAFkPsNofzWnujq21Ry7XSorS9j0AABACiWlMMK2bdv08MMP6xvf+EZorE+fPnrggQf0wgsv6He/+53OOeccTZ06VcuWLTvqcy1atEhFRUWhh8vlSvT0AWQYw5AqKiJ7/vh81rhhpGZeAAAgPXRqO9ytt96qH/7wh0eNqaur06hRo0LHPp9P5513nsrKyvTEE08c9dqrrrpKO3bskPconQjbWwlyuVxshwMgydrGNmxYx01PbTZrRWjHDra3AQCQbRKyHe6mm27S7NmzjxpzwgknhP69a9cuTZw4URMmTNDjjz8e9fnHjRunFStWHDWmoKBABQUFMc0XQO7xejtOgCTJNKWGBiuO7W4AAOSmTiVBAwYM0IABA2KK9fl8mjhxosaOHauamhrl5UXfebdx40Y56EIIoBv8/vjGAQCA7JOQwgg+n09lZWUaOnSo7r//fv3zn/8MnSspKZEkPf3008rPz9eZZ54pSTIMQ0899VTULXMAcDSx/h2Fv7cAAJC7EpIErVixQtu2bdO2bdvkdDrDzrW+Bel73/ue3nvvPfXo0UOjRo3S888/r4qKikRMCUCOcLute358PmvrW1vBe4Lc7uTPDQAApIek9QlKFPoEAWgrWB1OCk+EbDbra20tTU8BAMhGseYGSSmRDQDJ5PFYiU5pafi400kCBAAAktgsFQC6KhCwqrn5/da9PG539PLWHo9UXt756wAAQPYjCQKQ1gxDmj8/vOy10ylVV0df0bHbKYMNAAAisR0OQNoK3tvTtu+Pz2eNG0Zq5gUAADIbSRCAtBQIWCtA7ZVuCY5VVlpxAAAAnUESBCAteb2RK0CtmabU0GDFAQAAdAZJEIC05PfHNw4AACCIJAhAWnI44hsHAAAQRBIEIC253VYVuGCD07ZsNsnlsuIAAAA6gyQIQFqy260y2FJkIhQ8rqqi7w8AAOg8kiAAacvjkWprpdLS8HGn0xqP1icIAACgPTRLBZAUgYBVyc3vt+7jcbtjW8XxeKTy8q5dCwAA0B6SIAAJZxhWz5/WJa+dTmu7WyyrOXa7VFaWsOkBAIAcw3Y4AAllGFJFRWTPH5/PGjeM1MwLAADkLpIgAAkTCFgrQKYZeS44VllpxQEAACQLSRCAhPF6I1eAWjNNqaHBigMAAEgWkiAACeP3xzcOAAAgHkiCACSMwxHfOAAAgHggCQKQMG63VQWubbPTIJtNcrmsOAAAgGQhCQKQMHa7VQZbikyEgsdVVfT8AQAAyUUSBCChPB6ptlYqLQ0fdzqt8Vj6BAEAAMQTzVIBdEogYFVz8/ute3nc7ugrOR6PVF7e+esAAAASgSQIQMwMw+r707rstdNpbXmLtqJjt0tlZQmdHgAAQEzYDgcgJoYhVVRE9v3x+axxw0jNvAAAADqLJAhAVIGAtQJkmpHngmOVlVYcAABAuiMJAhCV1xu5AtSaaUoNDVYcAABAuiMJAhCV3x/fOAAAgFQiCQIQlcMR3zgAAIBUIgkCEJXbbVWBa9vwNMhmk1wuKw4AACDdkQQBiMput8pgS5GJUPC4qoq+PwAAIDOQBAGIiccj1dZKpaXh406nNR6tTxAAAEC6oFkqkKMCAauam99v3cvjdkdfyfF4pPLyzl8HAACQTkiCgBxkGFbfn9Zlr51Oa8tbtBUdu10qK0vo9AAAABKK7XBAjjEMqaIisu+Pz2eNG0Zq5gUAAJAsJEFADgkErBUg04w8FxyrrLTiAAAAshVJEJBDvN7IFaDWTFNqaLDiAAAAshVJEJBD/P74xgEAAGQikiAghzgc8Y0DAADIRCRBQA5xu60qcG0bngbZbJLLZcUBAABkK5IgIIfY7VYZbCkyEQoeV1XR9wcAAGQ3kiAgx3g8Um2tVFoaPu50WuPR+gQBAABkOpqlAhksELAqufn91n08bndsqzgej1Re3rVrAQAAMh1JEJChDMPq+dO65LXTaW13i2U1x26XysoSNj0AAIC0xXY4IAMZhlRREdnzx+ezxg0jNfMCAADIBCRBQIYJBKwVINOMPBccq6y04gAAABCJJAjIMF5v5ApQa6YpNTRYcQAAAIhEEgRkGL8/vnEAAAC5hiQIyDAOR3zjAAAAcg1JEJBh3G6rClzbZqdBNpvkcllxAAAAiEQSBGQYu90qgy1FJkLB46oqev4AAAB0hCQIyEAej1RbK5WWho87ndZ4LH2CAAAAchXNUoE0EAhY1dz8futeHrc7+kqOxyOVl3f+OgAAgFyXsJWgYcOGyWazhT3uueeesJhNmzbJ7XbrmGOOkcvl0r333puo6QBpyzCkYcOkiROlmTOtr8OGxdbw1G6XysqkGTOsryRAAAAA0SV0Jejuu+/WnDlzQsd9+/YN/bupqUkXXHCBJk2apEcffVR//etf9bWvfU3FxcW69tprEzktIG0YhlRREdn41OezxtnaBgAAEH8JTYL69u2rkpKSds8988wzOnTokJ566inl5+frlFNO0caNG/Xggw+SBCEnBALS/PmRCZBkjdlsUmWlteWNFR4AAID4SWhhhHvuuUf9+/fXmWeeqfvuu09HjhwJnVuzZo3OPfdc5efnh8YmT56sLVu26KOPPurwOZubm9XU1BT2ADKR1yu9/37H501Tamiw4gAAABA/CVsJuuGGG3TWWWepX79+evPNN7Vw4UL5/X49+OCDkqTdu3dr+PDhYdcMGjQodO64445r93kXLVqku+66K1HTBpLG749vHAAAAGLTqZWgW2+9NaLYQdvH5s2bJUkLFixQWVmZTjvtNH3zm9/UAw88oIcffljNzc3dmvDChQvV2NgYejQ0NHTr+YBUcTjiGwcAAIDYdGol6KabbtLs2bOPGnPCCSe0Oz5u3DgdOXJEO3fu1MiRI1VSUqI9e/aExQSPO7qPSJIKCgpUUFDQmWkDacnttvr6+Hzt3xdks1nn3e7kzw0AACCbdSoJGjBggAYMGNClb7Rx40bl5eVp4MCBkqTx48frf/7nf3T48GH17NlTkrRixQqNHDmyw61wQDax26XqaqsKnM0WngjZbNbXqiqKIgAAAMRbQgojrFmzRlVVVfrLX/6if/zjH3rmmWd044036qtf/WoowZk5c6by8/N1zTXX6G9/+5uef/55VVdXa8GCBYmYEpCWPB6rDHZpafi400l5bAAAgESxmWZ7G3G6589//rOuu+46bd68Wc3NzRo+fLiuvPJKLViwIGwr26ZNmzR37lytX79exx9/vK6//nrdcsstnfpeTU1NKioqUmNjowoLC+P9UoCYBQJWJTe/37qPx+2OfRWnO9cCAADAEmtukJAkKJlIgpAODMPq+dO65LXTaW13YzUHAAAgOWLNDRLaJwjIBYZh3dfTtuePz2eNG0Zq5gUAAID2kQQB3RAIWCtA7a2nBscqK604AAAApAeSIKAbvN7IFaDWTFNqaLDiAAAAkB5IgoBu8PvjGwcAAIDEIwkCusHhiG8cAAAAEo8kCOgGt9uqAhdsbtqWzSa5XFYcAAAA0gNJENANdrtVBluKTISCx1VV9PwBAABIJyRBQDd5PFJtrVRaGj7udFrj9AkCAABILz1SPQEg3QQCVjU3v9+6l8ftjr6S4/FI5eWdvw4AAADJRxIEtGIYVt+f1mWvnU5ry1u0FR27XSorS+j0AAAAEAdshwM+YxhSRUVk3x+fzxo3jNTMCwAAAPFFEgTI2gI3f77V3LSt4FhlpRUHAACAzEYSBMi6l6ftClBrpik1NFhxAAAAyGwkQYCsYgbxjAMAAED6IgkCZFVzi2ccAAAA0hdJECCrnLXTGdnwNMhmk1wuKw4AAACZjSQIkFXeurra+nfbRCh4XFVF3x8AAIBsQBIEfMbjkWprpdLS8HGn0xqP1icIAAAAmYFmqchagYBVzc3vt+7lcbujr+R4PFJ5eeevAwAAQOYgCUJWMgyr70/rstdOp7XlLdqKjt0ulZUldHoAAABIIbbDIesYhlRREdn3x+ezxg0jNfMCAABAeiAJQlYJBKwVINOMPBccq6y04gAAAJCbSIKQVbzeyBWg1kxTamiw4gAAAJCbSIKQVfz++MYBAAAg+5AEIas4HPGNAwAAQPYhCUJWcbutKnBtG54G2WySy2XFAQAAIDeRBCGr2O1WGWwpMhEKHldV0fcHAAAgl5EEIet4PFJtrVRaGj7udFrj0foEAQAAILvRLBVpLRCwKrn5/dZ9PG53bKs4Ho9UXt61awEAAJDdSIKQtgzD6vnTuuS102ltd4tlNcdul8rKEjY9AAAAZCi2wyEtGYZUURHZ88fns8YNIzXzAgAAQOYjCULaCQSsFSDTjDwXHKustOIAAACAziIJQtrxeiNXgFozTamhwYoDAAAAOoskCGnH749vHAAAANAaSRDSjsMR3zgAAACgNZIgpB2326oC17bZaZDNJrlcVhwAAADQWSRBSDt2u1UGW4pMhILHVVX0/AEAAEDXkAQhLXk8Um2tVFoaPu50WuOx9AkCAAAA2kOzVCRFIGBVc/P7rXt53O7oKzkej1Re3vnrAAAAgKMhCULCGYbV96d12Wun09ryFm1Fx26XysoSOj0AAADkGLbDIaEMQ6qoiOz74/NZ44aRmnkBAAAgd5EEIWECAWsFyDQjzwXHKiutOAAAACBZSIKQMF5v5ApQa6YpNTRYcQAAAECykAQhYfz++MYBAAAA8UAShIRxOOIbBwAAAMQDSRASxu22qsC1bXgaZLNJLpcVBwAAACQLSRASxm63ymBLkYlQ8Liqir4/AAAASC6SICSUxyPV1kqlpeHjTqc1Hq1PEAAAABBvNEtFpwQCVjU3v9+6l8ftjr6S4/FI5eWdvw4AAABIBJIgxMwwrL4/rcteO53WlrdoKzp2u1RWltDpAQAAADFhOxxiYhhSRUVk3x+fzxo3jNTMCwAAAOishCRBq1evls1ma/exfv16SdLOnTvbPb927dpETAndEAhYK0CmGXkuOFZZacUBAAAA6S4h2+EmTJggf5sOmN/97ne1atUqnX322WHjK1eu1CmnnBI67t+/fyKmhG7weiNXgFozTamhwYpjyxsAAADSXUKSoPz8fJWUlISODx8+rN/85je6/vrrZWtTK7l///5hsUg/bfLZbscBAAAAqZSUe4KWLVumDz74QFdffXXEuUsvvVQDBw7UOeeco2XLlkV9rubmZjU1NYU9kFgOR3zjAAAAgFRKShL05JNPavLkyXI6naGxPn366IEHHtALL7yg3/3udzrnnHM0derUqInQokWLVFRUFHq4XK5ETz/nud1WFbi2DU+DbDbJ5bLiAAAAgHRnM832bndv36233qof/vCHR42pq6vTqFGjQsfvv/++hg4dqiVLluiyyy476rVXXXWVduzYIa/X22FMc3OzmpubQ8dNTU1yuVxqbGxUYWFhjK8EnRWsDieFF0gIJkY0PgUAAECqNTU1qaioKGpu0Kl7gm666SbNnj37qDEnnHBC2HFNTY369++vSy+9NOrzjxs3TitWrDhqTEFBgQoKCqI+F+LL47ESnfb6BFVVkQABAAAgc3QqCRowYIAGDBgQc7xpmqqpqdFVV12lnj17Ro3fuHGjHNxYknCBgFXJze+37uNxu61mptF4PFJ5edeuBQAAANJFQqrDBb388svasWOHvv71r0ece/rpp5Wfn68zzzxTkmQYhp566ik98cQTiZxSzjOM9ldzqqtjW82x2ymDDQAAgMyW0CToySef1IQJE8LuEWrte9/7nt577z316NFDo0aN0vPPP6+K4I0niLvgfT1t7wLz+axx7usBAABALuhUYYR0FOvNT7kuEJCGDeu46anNZq0I7djB9jYAAABkplhzg6SUyEbqeb0dJ0CStTrU0GDFAQAAANmMJChH+P3xjQMAAAAyFUlQjoi16B7F+QAAAJDtSIJyhNtt3fMTbG7als0muVxWHAAAAJDNSIJyhN1ulcGWIhOh4HFVFUURAAAAkP1IgnKIx2OVwS4tDR93OimPDQAAgNyR0D5BSKxAwKrm5vdb9/K43dFXcjweqby889cBAAAA2YIkKEMZhjR/fnjZa6fT2vIWbUXHbpfKyhI6PQAAACBtsR0uAxmGVFER2ffH57PGDSM18wIAAAAyAUlQhgkErBUg04w8FxyrrLTiAAAAAEQiCcowXm/kClBrpik1NFhxAAAAACKRBGUYvz++cQAAAECuIQnKMA5HfOMAAACAXEMSlGHcbqsKXNuGp0E2m+RyWXEAAAAAIpEEZRi73SqDLUUmQsHjqir6/gAAAAAdIQnKQB6PVFsrlZaGjzud1ni0PkEAAABALqNZaooFAlYlN7/fuo/H7Y5tFcfjkcrLu3YtAAAAkMtIglLIMKyeP61LXjud1na3WFZz7HaprCxh0wMAAACyEtvhUsQwpIqKyJ4/Pp81bhipmRcAAACQ7UiCUiAQsFaATDPyXHCsstKKAwAAABBfJEEp4PVGrgC1ZppSQ4MVBwAAACC+SIJSwO+PbxwAAACA2JEEpYDDEd84AAAAALEjCUoBt9uqAte22WmQzSa5XFYcAAAAgPgiCUoBu90qgy1FJkLB46oqev4AAAAAiUASlCIej1RbK5WWho87ndZ4LH2CAAAAAHQezVLjJBCwqrn5/da9PG539JUcj0cqL+/8dQAAAAC6jiQoDgzD6vvTuuy102lteYu2omO3S2VlCZ0eAAAAgFbYDtdNhiFVVET2/fH5rHHDSM28AAAAALSPJKgbAgFrBcg0I88FxyorrTgAAAAA6YEkqBu83sgVoNZMU2posOIAAAAApAeSoG7w++MbBwAAACDxSIK6weGIbxwAAACAxCMJ6ga326oC17bhaZDNJrlcVhwAAACA9EAS1A12u1UGW4pMhILHVVX0/QEAAADSCUlQN3k8Um2tVFoaPu50WuPR+gQBAAAASC6apcaBxyOVl1tV4Px+6x4gt5sVIAAAACAdkQTFid0ulZWlehYAAAAAomE7HAAAAICcQhIEAAAAIKeQBAEAAADIKSRBAAAAAHIKSRAAAACAnEISBAAAACCnkAQBAAAAyCkkQQAAAAByCkkQAAAAgJxCEgQAAAAgp5AEAQAAAMgpJEEAAAAAcgpJEAAAAICcQhIEAAAAIKeQBAEAAADIKSRBAAAAAHJKj1RPoLtM05QkNTU1pXgmAAAAAFIpmBMEc4SOZHwStH//fkmSy+VK8UwAAAAApIP9+/erqKiow/M2M1qalOZaWlq0a9cu9e3bVzabLaVzaWpqksvlUkNDgwoLC1M6l2zG+5wcvM/JwfucHLzPicd7nBy8z8nB+5wciXifTdPU/v37NXjwYOXldXznT8avBOXl5cnpdKZ6GmEKCwv5H0wS8D4nB+9zcvA+Jwfvc+LxHicH73Ny8D4nR7zf56OtAAVRGAEAAABATiEJAgAAAJBTSILiqKCgQHfccYcKCgpSPZWsxvucHLzPycH7nBy8z4nHe5wcvM/JwfucHKl8nzO+MAIAAAAAdAYrQQAAAAByCkkQAAAAgJxCEgQAAAAgp5AEAQAAAMgpJEEAAAAAcgpJUBf94Ac/0IQJE9S7d28VFxe3G1NfX6+LL75YvXv31sCBA/Xtb39bR44cCYtZvXq1zjrrLBUUFGjEiBFavHhx4iefoVavXi2bzdbuY/369ZKknTt3tnt+7dq1KZ59Zhk2bFjEe3jPPfeExWzatElut1vHHHOMXC6X7r333hTNNjPt3LlT11xzjYYPH65evXrpxBNP1B133KFDhw6FxfB57r5HHnlEw4YN0zHHHKNx48bprbfeSvWUMtqiRYv0+c9/Xn379tXAgQM1depUbdmyJSymrKws4nP7zW9+M0Uzzkx33nlnxHs4atSo0PmDBw9q7ty56t+/v/r06aPLLrtMe/bsSeGMM1N7/39ns9k0d+5cSXyWu+K1117TJZdcosGDB8tms2np0qVh503T1O233y6Hw6FevXpp0qRJ2rp1a1jMhx9+qCuuuEKFhYUqLi7WNddco48//jiu8yQJ6qJDhw7pK1/5ir71rW+1ez4QCOjiiy/WoUOH9Oabb+rpp5/W4sWLdfvtt4diduzYoYsvvlgTJ07Uxo0bVVlZqa9//et66aWXkvUyMsqECRPk9/vDHl//+tc1fPhwnX322WGxK1euDIsbO3Zsimadue6+++6w9/D6668PnWtqatIFF1ygoUOHasOGDbrvvvt055136vHHH0/hjDPL5s2b1dLSoscee0x/+9vf9KMf/UiPPvqo/vu//zsils9z1z3//PNasGCB7rjjDv35z3/W6aefrsmTJ2vv3r2pnlrGevXVVzV37lytXbtWK1as0OHDh3XBBRfowIEDYXFz5swJ+9zyh5LOO+WUU8Lew9dffz107sYbb9Rvf/tbvfDCC3r11Ve1a9cueTyeFM42M61fvz7sPV6xYoUk6Stf+Uoohs9y5xw4cECnn366HnnkkXbP33vvvXrooYf06KOPat26dTr22GM1efJkHTx4MBRzxRVX6G9/+5tWrFihF198Ua+99pquvfba+E7URLfU1NSYRUVFEeO///3vzby8PHP37t2hsZ/+9KdmYWGh2dzcbJqmaX7nO98xTznllLDrLr/8cnPy5MkJnXO2OHTokDlgwADz7rvvDo3t2LHDlGS+/fbbqZtYFhg6dKj5ox/9qMPzP/nJT8zjjjsu9Fk2TdO85ZZbzJEjRyZhdtnr3nvvNYcPHx465vPcfV/4whfMuXPnho4DgYA5ePBgc9GiRSmcVXbZu3evKcl89dVXQ2PnnXeeOX/+/NRNKgvccccd5umnn97uuX379pk9e/Y0X3jhhdBYXV2dKclcs2ZNkmaYnebPn2+eeOKJZktLi2mafJa7S5L561//OnTc0tJilpSUmPfdd19obN++fWZBQYH53HPPmaZpmn//+99NSeb69etDMX/4wx9Mm81m+ny+uM2NlaAEWbNmjU499VQNGjQoNDZ58mQ1NTXpb3/7Wyhm0qRJYddNnjxZa9asSepcM9WyZcv0wQcf6Oqrr444d+mll2rgwIE655xztGzZshTMLvPdc8896t+/v84880zdd999YVs516xZo3PPPVf5+fmhscmTJ2vLli366KOPUjHdrNDY2Kh+/fpFjPN57ppDhw5pw4YNYT9n8/LyNGnSJH7OxlFjY6MkRXx2n3nmGR1//PEaM2aMFi5cqE8++SQV08toW7du1eDBg3XCCSfoiiuuUH19vSRpw4YNOnz4cNhne9SoURoyZAif7W44dOiQfvGLX+hrX/uabDZbaJzPcvzs2LFDu3fvDvvsFhUVady4caHP7po1a1RcXBy2y2fSpEnKy8vTunXr4jaXHnF7JoTZvXt3WAIkKXS8e/fuo8Y0NTXp008/Va9evZIz2Qz15JNPavLkyXI6naGxPn366IEHHtAXv/hF5eXl6Ve/+pWmTp2qpUuX6tJLL03hbDPLDTfcoLPOOkv9+vXTm2++qYULF8rv9+vBBx+UZH12hw8fHnZN68/3cccdl/Q5Z7pt27bp4Ycf1v333x8a4/PcPf/6178UCATa/Tm7efPmFM0qu7S0tKiyslJf/OIXNWbMmND4zJkzNXToUA0ePFibNm3SLbfcoi1btsgwjBTONrOMGzdOixcv1siRI+X3+3XXXXfJ7XbrnXfe0e7du5Wfnx9xT/KgQYNCv2Og85YuXap9+/Zp9uzZoTE+y/EV/Hy293O59e/HAwcODDvfo0cP9evXL66fb5KgVm699Vb98Ic/PGpMXV1d2I2J6L6uvO/vv/++XnrpJS1ZsiQs7vjjj9eCBQtCx5///Oe1a9cu3XfffTn/S2Nn3ufW7+Fpp52m/Px8feMb39CiRYtUUFCQ6KlmtK58nn0+n6ZMmaKvfOUrmjNnTmiczzPS3dy5c/XOO++E3asiKWzv/qmnniqHw6Hzzz9f27dv14knnpjsaWakCy+8MPTv0047TePGjdPQoUO1ZMkS/kiaIE8++aQuvPBCDR48ODTGZzl7kQS1ctNNN4Vl/+054YQTYnqukpKSiApEwaotJSUloa9tK7ns2bNHhYWFOfUDrivve01Njfr37x/TL4Ljxo0L3eiYy7rz+R43bpyOHDminTt3auTIkR1+dqV/f75zVWff5127dmnixImaMGFCTIUl+DzH7vjjj5fdbm/3s5rrn9N4mDdvXuiG5dYr8u0ZN26cJGvFk18cu6a4uFgnn3yytm3bpi996Us6dOiQ9u3bF7YaxGe769577z2tXLky6goPn+XuCX4+9+zZI4fDERrfs2ePzjjjjFBM2+I1R44c0YcffhjXzzdJUCsDBgzQgAED4vJc48eP1w9+8APt3bs3tKS3YsUKFRYW6nOf+1wo5ve//33YdStWrND48ePjModM0dn33TRN1dTU6KqrrlLPnj2jxm/cuDHsf2i5qjuf740bNyovLy/0WR4/frz+53/+R4cPHw79N1ixYoVGjhyZ81vhOvM++3w+TZw4UWPHjlVNTY3y8qLfpsnnOXb5+fkaO3asVq1apalTp0qytm+tWrVK8+bNS+3kMphpmrr++uv161//WqtXr47YGtuejRs3ShKf3W74+OOPtX37dl155ZUaO3asevbsqVWrVumyyy6TJG3ZskX19fU59ztEvNTU1GjgwIG6+OKLjxrHZ7l7hg8frpKSEq1atSqU9DQ1NWndunWhisvjx4/Xvn37tGHDhlA11JdfflktLS2hJDQu4lZiIce899575ttvv23eddddZp8+fcy3337bfPvtt839+/ebpmmaR44cMceMGWNecMEF5saNG83ly5ebAwYMMBcuXBh6jn/84x9m7969zW9/+9tmXV2d+cgjj5h2u91cvnx5ql5WRli5cqUpyayrq4s4t3jxYvPZZ5816+rqzLq6OvMHP/iBmZeXZz711FMpmGlmevPNN80f/ehH5saNG83t27ebv/jFL8wBAwaYV111VShm37595qBBg8wrr7zSfOedd8xf/vKXZu/evc3HHnsshTPPLO+//745YsQI8/zzzzfff/990+/3hx5BfJ6775e//KVZUFBgLl682Pz73/9uXnvttWZxcXFY5U50zre+9S2zqKjIXL16ddjn9pNPPjFN0zS3bdtm3n333eaf/vQnc8eOHeZvfvMb84QTTjDPPffcFM88s9x0003m6tWrzR07dphvvPGGOWnSJPP444839+7da5qmaX7zm980hwwZYr788svmn/70J3P8+PHm+PHjUzzrzBQIBMwhQ4aYt9xyS9g4n+Wu2b9/f+j3Yknmgw8+aL799tvme++9Z5qmad5zzz1mcXGx+Zvf/MbctGmTWV5ebg4fPtz89NNPQ88xZcoU88wzzzTXrVtnvv766+ZJJ51kzpgxI67zJAnqolmzZpmSIh6vvPJKKGbnzp3mhRdeaPbq1cs8/vjjzZtuusk8fPhw2PO88sor5hlnnGHm5+ebJ5xwgllTU5PcF5KBZsyYYU6YMKHdc4sXLzZHjx5t9u7d2ywsLDS/8IUvhJUQRXQbNmwwx40bZxYVFZnHHHOMOXr0aPN///d/zYMHD4bF/eUvfzHPOeccs6CgwCwtLTXvueeeFM04M9XU1LT7M6T136b4PMfHww8/bA4ZMsTMz883v/CFL5hr165N9ZQyWkef2+D/f9XX15vnnnuu2a9fP7OgoMAcMWKE+e1vf9tsbGxM7cQzzOWXX246HA4zPz/fLC0tNS+//HJz27ZtofOffvqped1115nHHXec2bt3b3PatGlhf0RB7F566SVTkrlly5awcT7LXfPKK6+0+zNi1qxZpmlaZbK/+93vmoMGDTILCgrM888/P+K9/+CDD8wZM2aYffr0MQsLC82rr746tNAQLzbTNM34rSsBAAAAQHqjTxAAAACAnEISBAAAACCnkAQBAAAAyCkkQQAAAAByCkkQAAAAgJxCEgQAAAAgp5AEAQAAAMgpJEEAAAAAcgpJEAAAAICcQhIEAAAAIKeQBAEAAADIKf8P0xrcv8N2UkIAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "38Ki8ZHcsztG"
      },
      "source": [
        "Strange, we trained for longer but our model performed worse?\n",
        "\n",
        "As it turns out, our model might've trained too long and has thus resulted in worse results (we'll see ways to prevent training for too long later on)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BPTUcFe4sbfk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0c65a24d-f775-4727-b5ba-5eaefa2f0f3b"
      },
      "source": [
        "# Calculate model_3 metrics\n",
        "mae_3 = mae(y_test, y_preds_3.squeeze()).numpy()\n",
        "mse_3 = mse(y_test, y_preds_3.squeeze()).numpy()\n",
        "mae_3, mse_3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(68.71385, 4808.09)"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UPEeM3UsrxGB"
      },
      "source": [
        "## Comparing results\n",
        "\n",
        "Now we've got results for 3 similar but slightly different results, let's compare them."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mw5RZk-BqLZd"
      },
      "source": [
        "model_results = [[\"model_1\", mae_1, mse_1],\n",
        "                 [\"model_2\", mae_2, mse_2],\n",
        "                 [\"model_3\", mae_3, mae_3]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ip7bKH83p5X0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        },
        "outputId": "5e336a7f-4200-4a29-c538-2b1e59fc681a"
      },
      "source": [
        "import pandas as pd\n",
        "all_results = pd.DataFrame(model_results, columns=[\"model\", \"mae\", \"mse\"])\n",
        "all_results"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "     model        mae         mse\n",
              "0  model_1  21.303345  457.282318\n",
              "1  model_2  26.216049  712.937866\n",
              "2  model_3  68.713852   68.713852"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-f6129e4b-5bfa-45e5-bd1f-df96b5690515\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>model</th>\n",
              "      <th>mae</th>\n",
              "      <th>mse</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>model_1</td>\n",
              "      <td>21.303345</td>\n",
              "      <td>457.282318</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>model_2</td>\n",
              "      <td>26.216049</td>\n",
              "      <td>712.937866</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>model_3</td>\n",
              "      <td>68.713852</td>\n",
              "      <td>68.713852</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-f6129e4b-5bfa-45e5-bd1f-df96b5690515')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-f6129e4b-5bfa-45e5-bd1f-df96b5690515 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-f6129e4b-5bfa-45e5-bd1f-df96b5690515');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o_AtUiwuuLGo"
      },
      "source": [
        "From our experiments, it looks like `model_2` performed the best.\n",
        "\n",
        "And now, you might be thinking, \"wow, comparing models is tedious...\" and it definitely can be, we've only compared 3 models here. \n",
        "\n",
        "But this is part of what machine learning modelling is about, trying many different combinations of models and seeing which performs best.\n",
        "\n",
        "Each model you build is a small experiment. \n",
        "\n",
        "> 🔑 **Note:** One of your main goals should be to minimize the time between your experiments. The more experiments you do, the more things you'll figure out which don't work and in turn, get closer to figuring out what does work. Remember the machine learning practitioner's motto: \"experiment, experiment, experiment\".\n",
        "\n",
        "Another thing you'll also find is what you thought may work (such as training a model for longer) may not always work and the exact opposite is also often the case.\n",
        "\n",
        "## Tracking your experiments\n",
        "\n",
        "One really good habit to get into is tracking your modelling experiments to see which perform better than others.\n",
        "\n",
        "We've done a simple version of this above (keeping the results in different variables).\n",
        "\n",
        "> 📖 **Resource:** But as you build more models, you'll want to look into using tools such as:\n",
        "* [**TensorBoard**](https://tensorboard.dev/) - a component of the TensorFlow library to help track modelling experiments (we'll see this later).\n",
        "* [**Weights & Biases**](https://www.wandb.com/) - a tool for tracking all kinds of machine learning experiments (the good news for Weights & Biases is it plugs into TensorBoard)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fe5DgNbX6192"
      },
      "source": [
        "## Saving a model\n",
        "\n",
        "Once you've trained a model and found one which performs to your liking, you'll probably want to save it for use elsewhere (like a web application or mobile device).\n",
        "\n",
        "You can save a TensorFlow/Keras model using [`model.save()`](https://www.tensorflow.org/tutorials/keras/save_and_load#save_the_entire_model).\n",
        "\n",
        "There are two ways to save a model in TensorFlow:\n",
        "1. The [SavedModel format](https://www.tensorflow.org/tutorials/keras/save_and_load#savedmodel_format) (default).\n",
        "2. The [HDF5 format](https://www.tensorflow.org/tutorials/keras/save_and_load#hdf5_format).\n",
        "\n",
        "The main difference between the two is the SavedModel is automatically able to save custom objects (such as special layers) without additional modifications when loading the model back in.\n",
        "\n",
        "Which one should you use?\n",
        "\n",
        "It depends on your situation but the SavedModel format will suffice most of the time.\n",
        "\n",
        "Both methods use the same method call."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gg0jD2cUoPsg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9eb644e5-2edb-4232-f6d5-c6fe7cc4f976"
      },
      "source": [
        "# Save a model using the SavedModel format\n",
        "model_2.save('best_model_SavedModel_format')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:Found untraced functions such as _update_step_xla while saving (showing 1 of 1). These functions will not be directly callable after loading.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dsCpDYrU7D1j",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c32d2448-62fc-443a-c732-c83fc35dda73"
      },
      "source": [
        "# Check it out - outputs a protobuf binary file (.pb) as well as other files\n",
        "!ls best_model_SavedModel_format"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "assets\tfingerprint.pb\tkeras_metadata.pb  saved_model.pb  variables\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NGKmWco_SOEU"
      },
      "source": [
        "Now let's save the model in the HDF5 format, we'll use the same method but with a different filename."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "97J6GJMBSM2j"
      },
      "source": [
        "# Save a model using the HDF5 format\n",
        "model_2.save(\"best_model_HDF5_format.h5\") # note the addition of '.h5' on the end"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vB7TmsSGSjdv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff659055-d396-412d-b017-0ab7e196a7e8"
      },
      "source": [
        "# Check it out\n",
        "!ls best_model_HDF5_format.h5"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "best_model_HDF5_format.h5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OGA02tY97EUI"
      },
      "source": [
        "## Loading a model\n",
        "\n",
        "We can load a saved model using the [`load_model()`](https://www.tensorflow.org/api_docs/python/tf/keras/models/load_model) method.\n",
        "\n",
        "Loading a model for the different formats (SavedModel and HDF5) is the same (as long as the pathnames to the particular formats are correct)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FzyLIWfs7Fvh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ed1b3f9-4b6f-436e-ab1c-5c20ae0eea39"
      },
      "source": [
        "# Load a model from the SavedModel format\n",
        "loaded_saved_model = tf.keras.models.load_model(\"best_model_SavedModel_format\")\n",
        "loaded_saved_model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_7\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_7 (Dense)             (None, 1)                 2         \n",
            "                                                                 \n",
            " dense_8 (Dense)             (None, 1)                 2         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 4\n",
            "Trainable params: 4\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MfGO0dCQTeQh"
      },
      "source": [
        "Now let's test it out."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7rehN8ZxTy43",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b784fc09-04ac-443a-9d98-8b465d63fba7"
      },
      "source": [
        "# Compare model_2 with the SavedModel version (should return True)\n",
        "model_2_preds = model_2.predict(X_test)\n",
        "saved_model_preds = loaded_saved_model.predict(X_test)\n",
        "mae(y_test, saved_model_preds.squeeze()).numpy() == mae(y_test, model_2_preds.squeeze()).numpy()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 30ms/step\n",
            "1/1 [==============================] - 0s 46ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "prjkfX6rUZ6a"
      },
      "source": [
        "Loading in from the HDF5 is much the same."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dQfx-bWKUfRQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "beec5e93-9250-4f31-fc24-592130f2afd5"
      },
      "source": [
        "# Load a model from the HDF5 format\n",
        "loaded_h5_model = tf.keras.models.load_model(\"best_model_HDF5_format.h5\")\n",
        "loaded_h5_model.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_7\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " dense_7 (Dense)             (None, 1)                 2         \n",
            "                                                                 \n",
            " dense_8 (Dense)             (None, 1)                 2         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 4\n",
            "Trainable params: 4\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L0kT91h-Uru-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c4b4584a-d2d4-448d-89b2-f11bcde79107"
      },
      "source": [
        "# Compare model_2 with the loaded HDF5 version (should return True)\n",
        "h5_model_preds = loaded_h5_model.predict(X_test)\n",
        "mae(y_test, h5_model_preds.squeeze()).numpy() == mae(y_test, model_2_preds.squeeze()).numpy()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1/1 [==============================] - 0s 59ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ABtsYBDtr5Zz"
      },
      "source": [
        "## Downloading a model (from Google Colab)\n",
        "\n",
        "Say you wanted to get your model from Google Colab to your local machine, you can do one of the following things:\n",
        "* Right click on the file in the files pane and click 'download'.\n",
        "* Use the code below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JV0onjIIr9XC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "outputId": "c2840e1b-2601-4fc5-c3ce-055d62264675"
      },
      "source": [
        "# Download the model (or any file) from Google Colab\n",
        "from google.colab import files\n",
        "files.download(\"best_model_HDF5_format.h5\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_da080b5d-3841-46aa-b8ee-1a0a5c51dd2c\", \"best_model_HDF5_format.h5\", 21952)"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7xpVdMtKw6X4"
      },
      "source": [
        "## A larger example\n",
        "\n",
        "Alright, we've seen the fundamentals of building neural network regression models in TensorFlow.\n",
        "\n",
        "Let's step it up a notch and build a model for a more feature rich dataset.\n",
        "\n",
        "More specifically we're going to try predict the cost of medical insurance for individuals based on a number of different parameters such as, `age`, `sex`, `bmi`, `children`, `smoking_status` and `residential_region`.\n",
        "\n",
        "To do, we'll leverage the pubically available [Medical Cost dataset](https://www.kaggle.com/mirichoi0218/insurance) available from Kaggle and [hosted on GitHub](https://github.com/stedy/Machine-Learning-with-R-datasets/blob/master/insurance.csv).\n",
        "\n",
        "> 🔑 **Note:** When learning machine learning paradigms, you'll often go through a series of foundational techniques and then practice them by working with open-source datasets and examples. Just as we're doing now, learn foundations, put them to work with different problems. Every time you work on something new, it's a good idea to search for something like \"problem X example with Python/TensorFlow\" where you substitute X for your problem."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WWK1LBxapgc2"
      },
      "source": [
        "# Import required libraries\n",
        "import tensorflow as tf\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JrnTr5N9blFo"
      },
      "source": [
        "# Read in the insurance dataset\n",
        "insurance = pd.read_csv(\"https://raw.githubusercontent.com/stedy/Machine-Learning-with-R-datasets/master/insurance.csv\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QtXPN7cfb4Nm",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "444e6c7a-bf83-4c43-bb0e-b509ea8fca7a"
      },
      "source": [
        "# Check out the insurance dataset\n",
        "insurance.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   age     sex     bmi  children smoker     region      charges\n",
              "0   19  female  27.900         0    yes  southwest  16884.92400\n",
              "1   18    male  33.770         1     no  southeast   1725.55230\n",
              "2   28    male  33.000         3     no  southeast   4449.46200\n",
              "3   33    male  22.705         0     no  northwest  21984.47061\n",
              "4   32    male  28.880         0     no  northwest   3866.85520"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-e0a5b77d-cd01-49c9-818a-8b5bb1ebd2c6\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>age</th>\n",
              "      <th>sex</th>\n",
              "      <th>bmi</th>\n",
              "      <th>children</th>\n",
              "      <th>smoker</th>\n",
              "      <th>region</th>\n",
              "      <th>charges</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>19</td>\n",
              "      <td>female</td>\n",
              "      <td>27.900</td>\n",
              "      <td>0</td>\n",
              "      <td>yes</td>\n",
              "      <td>southwest</td>\n",
              "      <td>16884.92400</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>18</td>\n",
              "      <td>male</td>\n",
              "      <td>33.770</td>\n",
              "      <td>1</td>\n",
              "      <td>no</td>\n",
              "      <td>southeast</td>\n",
              "      <td>1725.55230</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>28</td>\n",
              "      <td>male</td>\n",
              "      <td>33.000</td>\n",
              "      <td>3</td>\n",
              "      <td>no</td>\n",
              "      <td>southeast</td>\n",
              "      <td>4449.46200</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>33</td>\n",
              "      <td>male</td>\n",
              "      <td>22.705</td>\n",
              "      <td>0</td>\n",
              "      <td>no</td>\n",
              "      <td>northwest</td>\n",
              "      <td>21984.47061</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>32</td>\n",
              "      <td>male</td>\n",
              "      <td>28.880</td>\n",
              "      <td>0</td>\n",
              "      <td>no</td>\n",
              "      <td>northwest</td>\n",
              "      <td>3866.85520</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e0a5b77d-cd01-49c9-818a-8b5bb1ebd2c6')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-e0a5b77d-cd01-49c9-818a-8b5bb1ebd2c6 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-e0a5b77d-cd01-49c9-818a-8b5bb1ebd2c6');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s55oIsYv0KkZ"
      },
      "source": [
        "We're going to have to turn the non-numerical columns into numbers (because a neural network can't handle non-numerical inputs).\n",
        "\n",
        "To do so, we'll use the [`get_dummies()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.get_dummies.html) method in pandas.\n",
        "\n",
        "It converts categorical variables (like the `sex`, `smoker` and `region` columns) into numerical variables using one-hot encoding."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MqM_BmPkdon8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "4cfe3c7c-e554-46ec-a504-11ab359e887e"
      },
      "source": [
        "# Turn all categories into numbers\n",
        "insurance_one_hot = pd.get_dummies(insurance)\n",
        "insurance_one_hot.head() # view the converted columns"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   age     bmi  children      charges  sex_female  sex_male  smoker_no  \\\n",
              "0   19  27.900         0  16884.92400           1         0          0   \n",
              "1   18  33.770         1   1725.55230           0         1          1   \n",
              "2   28  33.000         3   4449.46200           0         1          1   \n",
              "3   33  22.705         0  21984.47061           0         1          1   \n",
              "4   32  28.880         0   3866.85520           0         1          1   \n",
              "\n",
              "   smoker_yes  region_northeast  region_northwest  region_southeast  \\\n",
              "0           1                 0                 0                 0   \n",
              "1           0                 0                 0                 1   \n",
              "2           0                 0                 0                 1   \n",
              "3           0                 0                 1                 0   \n",
              "4           0                 0                 1                 0   \n",
              "\n",
              "   region_southwest  \n",
              "0                 1  \n",
              "1                 0  \n",
              "2                 0  \n",
              "3                 0  \n",
              "4                 0  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-865f1e49-0e01-49ef-9f22-a2f895692f95\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>age</th>\n",
              "      <th>bmi</th>\n",
              "      <th>children</th>\n",
              "      <th>charges</th>\n",
              "      <th>sex_female</th>\n",
              "      <th>sex_male</th>\n",
              "      <th>smoker_no</th>\n",
              "      <th>smoker_yes</th>\n",
              "      <th>region_northeast</th>\n",
              "      <th>region_northwest</th>\n",
              "      <th>region_southeast</th>\n",
              "      <th>region_southwest</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>19</td>\n",
              "      <td>27.900</td>\n",
              "      <td>0</td>\n",
              "      <td>16884.92400</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>18</td>\n",
              "      <td>33.770</td>\n",
              "      <td>1</td>\n",
              "      <td>1725.55230</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>28</td>\n",
              "      <td>33.000</td>\n",
              "      <td>3</td>\n",
              "      <td>4449.46200</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>33</td>\n",
              "      <td>22.705</td>\n",
              "      <td>0</td>\n",
              "      <td>21984.47061</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>32</td>\n",
              "      <td>28.880</td>\n",
              "      <td>0</td>\n",
              "      <td>3866.85520</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-865f1e49-0e01-49ef-9f22-a2f895692f95')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-865f1e49-0e01-49ef-9f22-a2f895692f95 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-865f1e49-0e01-49ef-9f22-a2f895692f95');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zOHoPzgqgZPq"
      },
      "source": [
        "Now we'll split data into features (`X`) and labels (`y`)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W_EGj3FxhkAb"
      },
      "source": [
        "# Create X & y values\n",
        "X = insurance_one_hot.drop(\"charges\", axis=1)\n",
        "y = insurance_one_hot[\"charges\"]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "-QQFJmDn5ATV",
        "outputId": "504cd84e-4892-4945-fc83-328f10d84741"
      },
      "source": [
        "# View features\n",
        "X.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   age     bmi  children  sex_female  sex_male  smoker_no  smoker_yes  \\\n",
              "0   19  27.900         0           1         0          0           1   \n",
              "1   18  33.770         1           0         1          1           0   \n",
              "2   28  33.000         3           0         1          1           0   \n",
              "3   33  22.705         0           0         1          1           0   \n",
              "4   32  28.880         0           0         1          1           0   \n",
              "\n",
              "   region_northeast  region_northwest  region_southeast  region_southwest  \n",
              "0                 0                 0                 0                 1  \n",
              "1                 0                 0                 1                 0  \n",
              "2                 0                 0                 1                 0  \n",
              "3                 0                 1                 0                 0  \n",
              "4                 0                 1                 0                 0  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-e9094c54-9de9-46b8-9d70-0bc71492737d\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>age</th>\n",
              "      <th>bmi</th>\n",
              "      <th>children</th>\n",
              "      <th>sex_female</th>\n",
              "      <th>sex_male</th>\n",
              "      <th>smoker_no</th>\n",
              "      <th>smoker_yes</th>\n",
              "      <th>region_northeast</th>\n",
              "      <th>region_northwest</th>\n",
              "      <th>region_southeast</th>\n",
              "      <th>region_southwest</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>19</td>\n",
              "      <td>27.900</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>18</td>\n",
              "      <td>33.770</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>28</td>\n",
              "      <td>33.000</td>\n",
              "      <td>3</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>33</td>\n",
              "      <td>22.705</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>32</td>\n",
              "      <td>28.880</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e9094c54-9de9-46b8-9d70-0bc71492737d')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-e9094c54-9de9-46b8-9d70-0bc71492737d button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-e9094c54-9de9-46b8-9d70-0bc71492737d');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kudhkM-0giS1"
      },
      "source": [
        "And create training and test sets. We could do this manually, but to make it easier, we'll leverage the already available [`train_test_split`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) function available from Scikit-Learn."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WPGZGk0jhxCZ"
      },
      "source": [
        "# Create training and test sets\n",
        "from sklearn.model_selection import train_test_split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, \n",
        "                                                    y, \n",
        "                                                    test_size=0.2, \n",
        "                                                    random_state=42) # set random state for reproducible splits"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W8wEC0FPglnN"
      },
      "source": [
        "Now we can build and fit a model (we'll make it the same as `model_2`)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OCXTmz6oh_T6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b3c4104-3912-40c3-b6dd-00bb63d8cea8"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Create a new model (same as model_2)\n",
        "insurance_model = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(1),\n",
        "  tf.keras.layers.Dense(1)\n",
        "])\n",
        "\n",
        "# Compile the model\n",
        "insurance_model.compile(loss=tf.keras.losses.mae,\n",
        "                        optimizer=tf.keras.optimizers.SGD(),\n",
        "                        metrics=['mae'])\n",
        "\n",
        "# Fit the model\n",
        "insurance_model.fit(X_train, y_train, epochs=100)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/100\n",
            "34/34 [==============================] - 1s 3ms/step - loss: 9024.6133 - mae: 9024.6133\n",
            "Epoch 2/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7870.5664 - mae: 7870.5664\n",
            "Epoch 3/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7572.2773 - mae: 7572.2773\n",
            "Epoch 4/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7823.3257 - mae: 7823.3257\n",
            "Epoch 5/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7606.3052 - mae: 7606.3052\n",
            "Epoch 6/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7599.9536 - mae: 7599.9536\n",
            "Epoch 7/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7581.7715 - mae: 7581.7715\n",
            "Epoch 8/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7703.9424 - mae: 7703.9424\n",
            "Epoch 9/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7553.2603 - mae: 7553.2603\n",
            "Epoch 10/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7764.5151 - mae: 7764.5151\n",
            "Epoch 11/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7437.8950 - mae: 7437.8950\n",
            "Epoch 12/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7675.4946 - mae: 7675.4946\n",
            "Epoch 13/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7619.9692 - mae: 7619.9692\n",
            "Epoch 14/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7784.3457 - mae: 7784.3457\n",
            "Epoch 15/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7566.6655 - mae: 7566.6655\n",
            "Epoch 16/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7691.3799 - mae: 7691.3799\n",
            "Epoch 17/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7566.8643 - mae: 7566.8643\n",
            "Epoch 18/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7809.1738 - mae: 7809.1738\n",
            "Epoch 19/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7784.3745 - mae: 7784.3745\n",
            "Epoch 20/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7868.3887 - mae: 7868.3887\n",
            "Epoch 21/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7532.0659 - mae: 7532.0659\n",
            "Epoch 22/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7737.5342 - mae: 7737.5342\n",
            "Epoch 23/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7747.9468 - mae: 7747.9468\n",
            "Epoch 24/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7564.5044 - mae: 7564.5044\n",
            "Epoch 25/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7678.2988 - mae: 7678.2988\n",
            "Epoch 26/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7659.9907 - mae: 7659.9907\n",
            "Epoch 27/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7426.3701 - mae: 7426.3701\n",
            "Epoch 28/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7389.5532 - mae: 7389.5532\n",
            "Epoch 29/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7619.4409 - mae: 7619.4409\n",
            "Epoch 30/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7696.1113 - mae: 7696.1113\n",
            "Epoch 31/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7644.0273 - mae: 7644.0273\n",
            "Epoch 32/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7513.6191 - mae: 7513.6191\n",
            "Epoch 33/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7540.6919 - mae: 7540.6919\n",
            "Epoch 34/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7387.6074 - mae: 7387.6074\n",
            "Epoch 35/100\n",
            "34/34 [==============================] - 0s 5ms/step - loss: 7596.3535 - mae: 7596.3535\n",
            "Epoch 36/100\n",
            "34/34 [==============================] - 0s 5ms/step - loss: 7571.3618 - mae: 7571.3618\n",
            "Epoch 37/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7574.2192 - mae: 7574.2192\n",
            "Epoch 38/100\n",
            "34/34 [==============================] - 0s 5ms/step - loss: 7360.6050 - mae: 7360.6050\n",
            "Epoch 39/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7526.8960 - mae: 7526.8960\n",
            "Epoch 40/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7497.1597 - mae: 7497.1597\n",
            "Epoch 41/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7733.8394 - mae: 7733.8394\n",
            "Epoch 42/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7439.6323 - mae: 7439.6323\n",
            "Epoch 43/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7674.3872 - mae: 7674.3872\n",
            "Epoch 44/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7405.3047 - mae: 7405.3047\n",
            "Epoch 45/100\n",
            "34/34 [==============================] - 0s 5ms/step - loss: 7475.3364 - mae: 7475.3364\n",
            "Epoch 46/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7449.2852 - mae: 7449.2852\n",
            "Epoch 47/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7356.2642 - mae: 7356.2642\n",
            "Epoch 48/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7334.5596 - mae: 7334.5596\n",
            "Epoch 49/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7550.4458 - mae: 7550.4458\n",
            "Epoch 50/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7536.7671 - mae: 7536.7671\n",
            "Epoch 51/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7289.4873 - mae: 7289.4873\n",
            "Epoch 52/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7550.2861 - mae: 7550.2861\n",
            "Epoch 53/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7567.8828 - mae: 7567.8828\n",
            "Epoch 54/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7299.6929 - mae: 7299.6929\n",
            "Epoch 55/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7471.7007 - mae: 7471.7007\n",
            "Epoch 56/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7248.7026 - mae: 7248.7026\n",
            "Epoch 57/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7455.0713 - mae: 7455.0713\n",
            "Epoch 58/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7476.5234 - mae: 7476.5234\n",
            "Epoch 59/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7538.0327 - mae: 7538.0327\n",
            "Epoch 60/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7471.9175 - mae: 7471.9175\n",
            "Epoch 61/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7323.8477 - mae: 7323.8477\n",
            "Epoch 62/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7391.6812 - mae: 7391.6812\n",
            "Epoch 63/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7345.3877 - mae: 7345.3877\n",
            "Epoch 64/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7340.9878 - mae: 7340.9878\n",
            "Epoch 65/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7361.4912 - mae: 7361.4912\n",
            "Epoch 66/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7436.6060 - mae: 7436.6060\n",
            "Epoch 67/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7277.7866 - mae: 7277.7866\n",
            "Epoch 68/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7393.7725 - mae: 7393.7725\n",
            "Epoch 69/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7571.9692 - mae: 7571.9692\n",
            "Epoch 70/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7540.9390 - mae: 7540.9390\n",
            "Epoch 71/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7148.9136 - mae: 7148.9136\n",
            "Epoch 72/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7050.2446 - mae: 7050.2446\n",
            "Epoch 73/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7482.2153 - mae: 7482.2153\n",
            "Epoch 74/100\n",
            "34/34 [==============================] - 0s 4ms/step - loss: 7413.1606 - mae: 7413.1606\n",
            "Epoch 75/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7258.4722 - mae: 7258.4722\n",
            "Epoch 76/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7199.4790 - mae: 7199.4790\n",
            "Epoch 77/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7328.3018 - mae: 7328.3018\n",
            "Epoch 78/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7354.5752 - mae: 7354.5752\n",
            "Epoch 79/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7367.1187 - mae: 7367.1187\n",
            "Epoch 80/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7166.6177 - mae: 7166.6177\n",
            "Epoch 81/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7232.6396 - mae: 7232.6396\n",
            "Epoch 82/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7218.7471 - mae: 7218.7471\n",
            "Epoch 83/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7472.0210 - mae: 7472.0210\n",
            "Epoch 84/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7265.8833 - mae: 7265.8833\n",
            "Epoch 85/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7425.3794 - mae: 7425.3794\n",
            "Epoch 86/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7543.0488 - mae: 7543.0488\n",
            "Epoch 87/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7283.2656 - mae: 7283.2656\n",
            "Epoch 88/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7383.9185 - mae: 7383.9185\n",
            "Epoch 89/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7369.8110 - mae: 7369.8110\n",
            "Epoch 90/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7098.0205 - mae: 7098.0205\n",
            "Epoch 91/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7287.0210 - mae: 7287.0210\n",
            "Epoch 92/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7271.3857 - mae: 7271.3857\n",
            "Epoch 93/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7568.2451 - mae: 7568.2451\n",
            "Epoch 94/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7190.1348 - mae: 7190.1348\n",
            "Epoch 95/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7512.2007 - mae: 7512.2007\n",
            "Epoch 96/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7097.5669 - mae: 7097.5669\n",
            "Epoch 97/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7166.5273 - mae: 7166.5273\n",
            "Epoch 98/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7300.3516 - mae: 7300.3516\n",
            "Epoch 99/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7107.6421 - mae: 7107.6421\n",
            "Epoch 100/100\n",
            "34/34 [==============================] - 0s 3ms/step - loss: 7294.8081 - mae: 7294.8081\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f5b9829b130>"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B1U7LqpKid0r",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6cc8a49f-21b7-480b-d13c-3f489722fab6"
      },
      "source": [
        "# Check the results of the insurance model\n",
        "insurance_model.evaluate(X_test, y_test)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9/9 [==============================] - 0s 3ms/step - loss: 8740.5908 - mae: 8740.5908\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[8740.5908203125, 8740.5908203125]"
            ]
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H9doNDToqDru"
      },
      "source": [
        "Our model didn't perform very well, let's try a bigger model.\n",
        "\n",
        "We'll try 3 things:\n",
        "- Increasing the number of layers (2 -> 3).\n",
        "- Increasing the number of units in each layer (except for the output layer).\n",
        "- Changing the optimizer (from SGD to Adam).\n",
        "\n",
        "Everything else will stay the same."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W59EqfqYimnR"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Add an extra layer and increase number of units\n",
        "insurance_model_2 = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(100), # 100 units\n",
        "  tf.keras.layers.Dense(10), # 10 units\n",
        "  tf.keras.layers.Dense(1) # 1 unit (important for output layer)\n",
        "])\n",
        "\n",
        "# Compile the model\n",
        "insurance_model_2.compile(loss=tf.keras.losses.mae,\n",
        "                          optimizer=tf.keras.optimizers.Adam(), # Adam works but SGD doesn't \n",
        "                          metrics=['mae'])\n",
        "\n",
        "# Fit the model and save the history (we can plot this)\n",
        "history = insurance_model_2.fit(X_train, y_train, epochs=100, verbose=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k9IbYWnOqmoT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "60c032a1-f2bd-4456-d432-c94b41a2f921"
      },
      "source": [
        "# Evaluate our larger model\n",
        "insurance_model_2.evaluate(X_test, y_test)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9/9 [==============================] - 0s 3ms/step - loss: 4632.9619 - mae: 4632.9619\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[4632.9619140625, 4632.9619140625]"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o9Rf3NosqriS"
      },
      "source": [
        "Much better! Using a larger model and the Adam optimizer results in almost half the error as the previous model.\n",
        "\n",
        "> 🔑 **Note:** For many problems, the [Adam optimizer](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam) is a great starting choice. See Andrei Karpathy's \"Adam is safe\" point from [*A Recipe for Training Neural Networks*](http://karpathy.github.io/2019/04/25/recipe/) for more. \n",
        "\n",
        "Let's check out the loss curves of our model, we should see a downward trend."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9SE55ANojcF_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "outputId": "d0a0a033-6ad1-4e06-90d9-45d4a0b7bd27"
      },
      "source": [
        "# Plot history (also known as a loss curve)\n",
        "pd.DataFrame(history.history).plot()\n",
        "plt.ylabel(\"loss\")\n",
        "plt.xlabel(\"epochs\");"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ckHqtn0srQ5q"
      },
      "source": [
        "From this, it looks like our model's loss (and MAE) were both still decreasing (in our case, MAE and loss are the same, hence the lines in the plot overlap eachother).\n",
        "\n",
        "What this tells us is the loss might go down if we try training it for longer.\n",
        "\n",
        "> 🤔 **Question:** How long should you train for? \n",
        "\n",
        "> It depends on what problem you're working on. Sometimes training won't take very long, other times it'll take longer than you expect. A common method is to set your model training for a very long time (e.g. 1000's of epochs) but set it up with an [EarlyStopping callback](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping) so it stops automatically when it stops improving. We'll see this in another module.\n",
        "\n",
        "Let's train the same model as above for a little longer. We can do this but calling fit on it again."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ucs62jV8jl6N"
      },
      "source": [
        "# Try training for a little longer (100 more epochs)\n",
        "history_2 = insurance_model_2.fit(X_train, y_train, epochs=100, verbose=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L2FZA1z1sxxs"
      },
      "source": [
        "How did the extra training go?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cxtiYB3qs0PZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "92588811-b8d6-4ff0-b030-8c4c34af7d14"
      },
      "source": [
        "# Evaluate the model trained for 200 total epochs\n",
        "insurance_model_2_loss, insurance_model_2_mae = insurance_model_2.evaluate(X_test, y_test)\n",
        "insurance_model_2_loss, insurance_model_2_mae"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9/9 [==============================] - 0s 4ms/step - loss: 3489.7046 - mae: 3489.7046\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3489.70458984375, 3489.70458984375)"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MzUySYEOs-O_"
      },
      "source": [
        "Boom! Training for an extra 100 epochs we see about a 10% decrease in error.\n",
        "\n",
        "How does the visual look?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BtYKSLeQjuzL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "outputId": "f9321da2-fac3-440e-b4cc-2d562e12aceb"
      },
      "source": [
        "# Plot the model trained for 200 total epochs loss curves\n",
        "pd.DataFrame(history_2.history).plot()\n",
        "plt.ylabel(\"loss\")\n",
        "plt.xlabel(\"epochs\"); # note: epochs will only show 100 since we overrid the history variable"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HS8xYkvIuVZZ"
      },
      "source": [
        "## Preprocessing data (normalization and standardization)\n",
        "\n",
        "A common practice when working with neural networks is to make sure all of the data you pass to them is in the range 0 to 1.\n",
        "\n",
        "This practice is called **normalization** (scaling all values from their original range to, e.g. between 0 and 100,000 to be between 0 and 1).\n",
        "\n",
        "There is another process call **standardization** which converts all of your data to unit variance and 0 mean.\n",
        "\n",
        "These two practices are often part of a preprocessing pipeline (a series of functions to prepare your data for use with neural networks).\n",
        "\n",
        "Knowing this, some of the major steps you'll take to preprocess your data for a neural network include:\n",
        "* Turning all of your data to numbers (a neural network can't handle strings).\n",
        "* Making sure your data is in the right shape (verifying input and output shapes).\n",
        "* [**Feature scaling**](https://scikit-learn.org/stable/modules/preprocessing.html#preprocessing-scaler):\n",
        "    * Normalizing data (making sure all values are between 0 and 1). This is done by subtracting the minimum value then dividing by the maximum value minus the minimum. This is also referred to as min-max scaling.\n",
        "    * Standardization (making sure all values have a mean of 0 and a variance of 1). This is done by subtracting the mean value from the target feature and then dividing it by the standard deviation.\n",
        "    * Which one should you use?\n",
        "      * **With neural networks you'll tend to favour normalization** as they tend to prefer values between 0 and 1 (you'll see this espcially with image processing), however, you'll often find a neural network can perform pretty well with minimal feature scaling.\n",
        "\n",
        "> 📖 **Resource:** For more on preprocessing data, I'd recommend reading the following resources:\n",
        "* [Scikit-Learn's documentation on preprocessing data](https://scikit-learn.org/stable/modules/preprocessing.html#preprocessing-data).\n",
        "* [Scale, Standardize or Normalize with Scikit-Learn by Jeff Hale](https://towardsdatascience.com/scale-standardize-or-normalize-with-scikit-learn-6ccc7d176a02).\n",
        "\n",
        "We've already turned our data into numbers using `get_dummies()`, let's see how we'd normalize it as well."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9v7P20A2d7H6"
      },
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "\n",
        "# Read in the insurance dataset\n",
        "insurance = pd.read_csv(\"https://raw.githubusercontent.com/stedy/Machine-Learning-with-R-datasets/master/insurance.csv\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vir8UAIwlUOo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "outputId": "9bddf5b6-59d1-4d27-f3fa-cf05826c5bd4"
      },
      "source": [
        "# Check out the data\n",
        "insurance.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   age     sex     bmi  children smoker     region      charges\n",
              "0   19  female  27.900         0    yes  southwest  16884.92400\n",
              "1   18    male  33.770         1     no  southeast   1725.55230\n",
              "2   28    male  33.000         3     no  southeast   4449.46200\n",
              "3   33    male  22.705         0     no  northwest  21984.47061\n",
              "4   32    male  28.880         0     no  northwest   3866.85520"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-9e3f2f1d-7cce-4db3-84d3-35feb451e91b\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>age</th>\n",
              "      <th>sex</th>\n",
              "      <th>bmi</th>\n",
              "      <th>children</th>\n",
              "      <th>smoker</th>\n",
              "      <th>region</th>\n",
              "      <th>charges</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>19</td>\n",
              "      <td>female</td>\n",
              "      <td>27.900</td>\n",
              "      <td>0</td>\n",
              "      <td>yes</td>\n",
              "      <td>southwest</td>\n",
              "      <td>16884.92400</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>18</td>\n",
              "      <td>male</td>\n",
              "      <td>33.770</td>\n",
              "      <td>1</td>\n",
              "      <td>no</td>\n",
              "      <td>southeast</td>\n",
              "      <td>1725.55230</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>28</td>\n",
              "      <td>male</td>\n",
              "      <td>33.000</td>\n",
              "      <td>3</td>\n",
              "      <td>no</td>\n",
              "      <td>southeast</td>\n",
              "      <td>4449.46200</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>33</td>\n",
              "      <td>male</td>\n",
              "      <td>22.705</td>\n",
              "      <td>0</td>\n",
              "      <td>no</td>\n",
              "      <td>northwest</td>\n",
              "      <td>21984.47061</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>32</td>\n",
              "      <td>male</td>\n",
              "      <td>28.880</td>\n",
              "      <td>0</td>\n",
              "      <td>no</td>\n",
              "      <td>northwest</td>\n",
              "      <td>3866.85520</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-9e3f2f1d-7cce-4db3-84d3-35feb451e91b')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-9e3f2f1d-7cce-4db3-84d3-35feb451e91b button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-9e3f2f1d-7cce-4db3-84d3-35feb451e91b');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SHMQiNosg3J3"
      },
      "source": [
        "Now, just as before, we need to transform the non-numerical columns into numbers and this time we'll also be normalizing the numerical columns with different ranges (to make sure they're all between 0 and 1).\n",
        "\n",
        "To do this, we're going to use a few classes from Scikit-Learn:\n",
        "* [`make_column_transformer`](https://scikit-learn.org/stable/modules/generated/sklearn.compose.make_column_transformer.html) - build a multi-step data preprocessing function for the folllowing transformations:\n",
        "  * [`MinMaxScaler`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html) - make sure all numerical columns are normalized (between 0 and 1).\n",
        "  * [`OneHotEncoder`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html) - one hot encode the non-numerical columns.\n",
        "\n",
        "Let's see them in action."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-x9JwbV0hqWh"
      },
      "source": [
        "from sklearn.compose import make_column_transformer\n",
        "from sklearn.preprocessing import MinMaxScaler, OneHotEncoder\n",
        "\n",
        "# Create column transformer (this will help us normalize/preprocess our data)\n",
        "ct = make_column_transformer(\n",
        "    (MinMaxScaler(), [\"age\", \"bmi\", \"children\"]), # get all values between 0 and 1\n",
        "    (OneHotEncoder(handle_unknown=\"ignore\"), [\"sex\", \"smoker\", \"region\"])\n",
        ")\n",
        "\n",
        "# Create X & y\n",
        "X = insurance.drop(\"charges\", axis=1)\n",
        "y = insurance[\"charges\"]\n",
        "\n",
        "# Build our train and test sets (use random state to ensure same split as before)\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
        "\n",
        "# Fit column transformer on the training data only (doing so on test data would result in data leakage)\n",
        "ct.fit(X_train)\n",
        "\n",
        "# Transform training and test data with normalization (MinMaxScalar) and one hot encoding (OneHotEncoder)\n",
        "X_train_normal = ct.transform(X_train)\n",
        "X_test_normal = ct.transform(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tz58y3nPiBJ-"
      },
      "source": [
        "Now we've normalized it and one-hot encoding it, what does our data look like now?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VODt2YiziK45",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6994e780-3066-4599-8c37-c89793fc87b0"
      },
      "source": [
        "# Non-normalized and non-one-hot encoded data example\n",
        "X_train.loc[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "age                19\n",
              "sex            female\n",
              "bmi              27.9\n",
              "children            0\n",
              "smoker            yes\n",
              "region      southwest\n",
              "Name: 0, dtype: object"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mMYDXdwUnNVt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "824476df-b8c3-46be-d9bf-da33c260a43c"
      },
      "source": [
        "# Normalized and one-hot encoded example\n",
        "X_train_normal[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.60869565, 0.10734463, 0.4       , 1.        , 0.        ,\n",
              "       1.        , 0.        , 0.        , 1.        , 0.        ,\n",
              "       0.        ])"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9iI4KtfWib44"
      },
      "source": [
        "How about the shapes?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SFmxzqrWntj7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8fbfb438-8c63-4870-bd41-8a92ea438eeb"
      },
      "source": [
        "# Notice the normalized/one-hot encoded shape is larger because of the extra columns\n",
        "X_train_normal.shape, X_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((1070, 11), (1070, 6))"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MST951aYijTS"
      },
      "source": [
        "Our data is normalized and numerical, let's model it.\n",
        "\n",
        "We'll use the same model as `insurance_model_2`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TdHnIQqll83Y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5e836c17-d8a4-46fa-f7c0-c2a37f32163e"
      },
      "source": [
        "# Set random seed\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "# Build the model (3 layers, 100, 10, 1 units)\n",
        "insurance_model_3 = tf.keras.Sequential([\n",
        "  tf.keras.layers.Dense(100),\n",
        "  tf.keras.layers.Dense(10),\n",
        "  tf.keras.layers.Dense(1)\n",
        "])\n",
        "\n",
        "# Compile the model\n",
        "insurance_model_3.compile(loss=tf.keras.losses.mae,\n",
        "                          optimizer=tf.keras.optimizers.Adam(),\n",
        "                          metrics=['mae'])\n",
        "\n",
        "# Fit the model for 200 epochs (same as insurance_model_2)\n",
        "insurance_model_3.fit(X_train_normal, y_train, epochs=200, verbose=0) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f5bbe58c2b0>"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-DjwktO6jW41"
      },
      "source": [
        "Let's evaluate the model on normalized test set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sBcXZu9AnZfP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cbb4f7d0-e312-4040-97d1-972c0fd02cf7"
      },
      "source": [
        "# Evaulate 3rd model\n",
        "insurance_model_3_loss, insurance_model_3_mae = insurance_model_3.evaluate(X_test_normal, y_test)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "9/9 [==============================] - 0s 3ms/step - loss: 3174.2119 - mae: 3174.2119\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZlHro290jhtX"
      },
      "source": [
        "And finally, let's compare the results from `insurance_model_2` (trained on non-normalized data) and `insurance_model_3` (trained on normalized data)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ybZtnVlNjCJO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "78247a3a-c441-4421-f43d-fb4c934414e8"
      },
      "source": [
        "# Compare modelling results from non-normalized data and normalized data\n",
        "insurance_model_2_mae, insurance_model_3_mae"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3489.70458984375, 3174.2119140625)"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gUttViY4jzi8"
      },
      "source": [
        "From this we can see normalizing the data results in 10% less error using the same model than not normalizing the data.\n",
        "\n",
        "This is **one of the main benefits of normalization: faster convergence time** (a fancy way of saying, your model gets to better results faster).\n",
        "\n",
        "`insurance_model_2` may have eventually achieved the same results as `insurance_model_3` if we left it training for longer. \n",
        "\n",
        "Also, the results may change if we were to alter the architectures of the models, e.g. more hidden units per layer or more layers.\n",
        "\n",
        "But since our main goal as neural network practitioners is to decrease the time between experiments, anything that helps us get better results sooner is a plus."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NhIPO_KqocHP"
      },
      "source": [
        "## 🛠 Exercises\n",
        "\n",
        "We've a covered a whole lot pretty quickly.\n",
        "\n",
        "So now it's time to have a **play around** with a few things and start to build up your intuition.\n",
        "\n",
        "I emphasise the words play around because that's very important. Try a few things out, run the code and see what happens.\n",
        "\n",
        "1. Create your own regression dataset (or make the one we created in \"Create data to view and fit\" bigger) and build fit a model to it.\n",
        "2. Try building a neural network with 4 Dense layers and fitting it to your own regression dataset, how does it perform?\n",
        "3. Try and improve the results we got on the insurance dataset, some things you might want to try include:\n",
        "  * Building a larger model (how does one with 4 dense layers go?).\n",
        "  * Increasing the number of units in each layer.\n",
        "  * Lookup the documentation of [Adam](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam) and find out what the first parameter is, what happens if you increase it by 10x?\n",
        "  * What happens if you train for longer (say 300 epochs instead of 200)? \n",
        "4. Import the [Boston pricing dataset](https://www.tensorflow.org/api_docs/python/tf/keras/datasets/boston_housing/load_data) from TensorFlow [`tf.keras.datasets`](https://www.tensorflow.org/api_docs/python/tf/keras/datasets) and model it.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AyiHG2nubmu7"
      },
      "source": [
        "## 📖 Extra curriculum\n",
        "\n",
        "If you're looking for extra materials relating to this notebook, I'd check out the following:\n",
        "\n",
        "* [MIT introduction deep learning lecture 1](https://youtu.be/njKP3FqW3Sk) - gives a great overview of what's happening behind all of the code we're running.\n",
        "* Reading: 1-hour of [Chapter 1 of Neural Networks and Deep Learning](http://neuralnetworksanddeeplearning.com/chap1.html) by Michael Nielson - a great in-depth and hands-on example of the intuition behind neural networks.\n",
        "\n",
        "To practice your regression modelling with TensorFlow, I'd also encourage you to look through [Lion Bridge's collection of datasets](https://lionbridge.ai/datasets/) or [Kaggle's datasets](https://www.kaggle.com/data), find a regression dataset which sparks your interest and try to model."
      ]
    }
  ]
}