04-Keras_Syntax_Basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "colab": {
      "name": "00-Keras-Syntax-Basics.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "MojDfBsPbTG0"
      ]
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I6OQLKVbbTE-"
      },
      "source": [
        "# Keras Syntax Basics\n",
        "\n",
        "With TensorFlow 2.0 , Keras is now the main API choice. Let's work through a simple regression project to understand the basics of the Keras syntax and adding layers."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x-d7PYJ4bTE_"
      },
      "source": [
        "## The Data\n",
        "\n",
        "To learn the basic syntax of Keras, we will use a very simple fake data set, in the subsequent lectures we will focus on real datasets, along with feature engineering! For now, let's focus on the syntax of TensorFlow 2.0.\n",
        "\n",
        "Let's pretend this data are measurements of some rare gem stones, with 2 measurement features and a sale price. Our final goal would be to try to predict the sale price of a new gem stone we just mined from the ground, in order to try to set a fair price in the market.\n",
        "\n",
        "### Load the Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LHwweVEUbTFA"
      },
      "source": [
        "import pandas as pd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6arTnWqYb3G8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e51c45af-2e38-451c-d330-61ea3df56a5e"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive/\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HHWG5MDgb7OW"
      },
      "source": [
        "path = '/content/drive/My Drive/Colab Notebooks/UdemyFiles/DATA/fake_reg.csv'\n",
        "\n",
        "df=pd.read_csv(path)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rzh5-owIbTFJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "fdfdbf64-a755-4424-cf29-aab02354c46b"
      },
      "source": [
        "df.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>price</th>\n",
              "      <th>feature1</th>\n",
              "      <th>feature2</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>461.527929</td>\n",
              "      <td>999.787558</td>\n",
              "      <td>999.766096</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>548.130011</td>\n",
              "      <td>998.861615</td>\n",
              "      <td>1001.042403</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>410.297162</td>\n",
              "      <td>1000.070267</td>\n",
              "      <td>998.844015</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>540.382220</td>\n",
              "      <td>999.952251</td>\n",
              "      <td>1000.440940</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>546.024553</td>\n",
              "      <td>1000.446011</td>\n",
              "      <td>1000.338531</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "        price     feature1     feature2\n",
              "0  461.527929   999.787558   999.766096\n",
              "1  548.130011   998.861615  1001.042403\n",
              "2  410.297162  1000.070267   998.844015\n",
              "3  540.382220   999.952251  1000.440940\n",
              "4  546.024553  1000.446011  1000.338531"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zLugy5_qbTFQ"
      },
      "source": [
        "### Explore the data\n",
        "\n",
        "Let's take a quick look, we should see strong correlation between the features and the \"price\" of this made up product."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tI7HPZZYbTFQ"
      },
      "source": [
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "78ipyr9NbTFV",
        "outputId": "e803be11-15a6-41d5-eb5e-9608a7f50c43"
      },
      "source": [
        "sns.pairplot(df)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<seaborn.axisgrid.PairGrid at 0x259a3d72188>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 540x540 with 12 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pr2XsHUMbTFZ"
      },
      "source": [
        "Feel free to visualize more, but this data is fake, so we will focus on feature engineering and exploratory data analysis later on in the course in much more detail!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wS5_Ac5mbTFa"
      },
      "source": [
        "### Test/Train Split"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D1T0YzTObTFb"
      },
      "source": [
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "narfpIC-bTFg"
      },
      "source": [
        "# Convert Pandas to Numpy for Keras\n",
        "\n",
        "# Features\n",
        "X = df[['feature1','feature2']].values\n",
        "\n",
        "# Label\n",
        "y = df['price'].values\n",
        "\n",
        "# Split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=42)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yubePr6HbTFq",
        "outputId": "2bb2c01b-a8d9-4ab2-ab08-ac77bf897083"
      },
      "source": [
        "X_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(700, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "evRUr4MEbTFu",
        "outputId": "c0dd6f76-0852-4418-dce2-35aff8bf0c95"
      },
      "source": [
        "X_test.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(300, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QTeeXcV4bTFy",
        "outputId": "5b9643cd-d195-409c-f00e-fff1313ad6d5"
      },
      "source": [
        "y_train.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(700,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i_hJbutEbTF2",
        "outputId": "02a6820e-184d-4209-fc4b-32a52b2d8d8c"
      },
      "source": [
        "y_test.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(300,)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZicEVGsIbTF7"
      },
      "source": [
        "## Normalizing/Scaling the Data\n",
        "\n",
        "We scale the feature data.\n",
        "\n",
        "[Why we don't need to scale the label](https://stats.stackexchange.com/questions/111467/is-it-necessary-to-scale-the-target-value-in-addition-to-scaling-features-for-re)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WpbN4Y-XbTF8"
      },
      "source": [
        "from sklearn.preprocessing import MinMaxScaler"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EC-580FNbTF_",
        "outputId": "76aed53e-499d-4455-a108-3c08f8343083"
      },
      "source": [
        "help(MinMaxScaler)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on class MinMaxScaler in module sklearn.preprocessing.data:\n",
            "\n",
            "class MinMaxScaler(sklearn.base.BaseEstimator, sklearn.base.TransformerMixin)\n",
            " |  MinMaxScaler(feature_range=(0, 1), copy=True)\n",
            " |  \n",
            " |  Transforms features by scaling each feature to a given range.\n",
            " |  \n",
            " |  This estimator scales and translates each feature individually such\n",
            " |  that it is in the given range on the training set, e.g. between\n",
            " |  zero and one.\n",
            " |  \n",
            " |  The transformation is given by::\n",
            " |  \n",
            " |      X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))\n",
            " |      X_scaled = X_std * (max - min) + min\n",
            " |  \n",
            " |  where min, max = feature_range.\n",
            " |  \n",
            " |  The transformation is calculated as::\n",
            " |  \n",
            " |      X_scaled = scale * X + min - X.min(axis=0) * scale\n",
            " |      where scale = (max - min) / (X.max(axis=0) - X.min(axis=0))\n",
            " |  \n",
            " |  This transformation is often used as an alternative to zero mean,\n",
            " |  unit variance scaling.\n",
            " |  \n",
            " |  Read more in the :ref:`User Guide <preprocessing_scaler>`.\n",
            " |  \n",
            " |  Parameters\n",
            " |  ----------\n",
            " |  feature_range : tuple (min, max), default=(0, 1)\n",
            " |      Desired range of transformed data.\n",
            " |  \n",
            " |  copy : boolean, optional, default True\n",
            " |      Set to False to perform inplace row normalization and avoid a\n",
            " |      copy (if the input is already a numpy array).\n",
            " |  \n",
            " |  Attributes\n",
            " |  ----------\n",
            " |  min_ : ndarray, shape (n_features,)\n",
            " |      Per feature adjustment for minimum. Equivalent to\n",
            " |      ``min - X.min(axis=0) * self.scale_``\n",
            " |  \n",
            " |  scale_ : ndarray, shape (n_features,)\n",
            " |      Per feature relative scaling of the data. Equivalent to\n",
            " |      ``(max - min) / (X.max(axis=0) - X.min(axis=0))``\n",
            " |  \n",
            " |      .. versionadded:: 0.17\n",
            " |         *scale_* attribute.\n",
            " |  \n",
            " |  data_min_ : ndarray, shape (n_features,)\n",
            " |      Per feature minimum seen in the data\n",
            " |  \n",
            " |      .. versionadded:: 0.17\n",
            " |         *data_min_*\n",
            " |  \n",
            " |  data_max_ : ndarray, shape (n_features,)\n",
            " |      Per feature maximum seen in the data\n",
            " |  \n",
            " |      .. versionadded:: 0.17\n",
            " |         *data_max_*\n",
            " |  \n",
            " |  data_range_ : ndarray, shape (n_features,)\n",
            " |      Per feature range ``(data_max_ - data_min_)`` seen in the data\n",
            " |  \n",
            " |      .. versionadded:: 0.17\n",
            " |         *data_range_*\n",
            " |  \n",
            " |  Examples\n",
            " |  --------\n",
            " |  >>> from sklearn.preprocessing import MinMaxScaler\n",
            " |  >>> data = [[-1, 2], [-0.5, 6], [0, 10], [1, 18]]\n",
            " |  >>> scaler = MinMaxScaler()\n",
            " |  >>> print(scaler.fit(data))\n",
            " |  MinMaxScaler(copy=True, feature_range=(0, 1))\n",
            " |  >>> print(scaler.data_max_)\n",
            " |  [ 1. 18.]\n",
            " |  >>> print(scaler.transform(data))\n",
            " |  [[0.   0.  ]\n",
            " |   [0.25 0.25]\n",
            " |   [0.5  0.5 ]\n",
            " |   [1.   1.  ]]\n",
            " |  >>> print(scaler.transform([[2, 2]]))\n",
            " |  [[1.5 0. ]]\n",
            " |  \n",
            " |  See also\n",
            " |  --------\n",
            " |  minmax_scale: Equivalent function without the estimator API.\n",
            " |  \n",
            " |  Notes\n",
            " |  -----\n",
            " |  NaNs are treated as missing values: disregarded in fit, and maintained in\n",
            " |  transform.\n",
            " |  \n",
            " |  For a comparison of the different scalers, transformers, and normalizers,\n",
            " |  see :ref:`examples/preprocessing/plot_all_scaling.py\n",
            " |  <sphx_glr_auto_examples_preprocessing_plot_all_scaling.py>`.\n",
            " |  \n",
            " |  Method resolution order:\n",
            " |      MinMaxScaler\n",
            " |      sklearn.base.BaseEstimator\n",
            " |      sklearn.base.TransformerMixin\n",
            " |      builtins.object\n",
            " |  \n",
            " |  Methods defined here:\n",
            " |  \n",
            " |  __init__(self, feature_range=(0, 1), copy=True)\n",
            " |      Initialize self.  See help(type(self)) for accurate signature.\n",
            " |  \n",
            " |  fit(self, X, y=None)\n",
            " |      Compute the minimum and maximum to be used for later scaling.\n",
            " |      \n",
            " |      Parameters\n",
            " |      ----------\n",
            " |      X : array-like, shape [n_samples, n_features]\n",
            " |          The data used to compute the per-feature minimum and maximum\n",
            " |          used for later scaling along the features axis.\n",
            " |  \n",
            " |  inverse_transform(self, X)\n",
            " |      Undo the scaling of X according to feature_range.\n",
            " |      \n",
            " |      Parameters\n",
            " |      ----------\n",
            " |      X : array-like, shape [n_samples, n_features]\n",
            " |          Input data that will be transformed. It cannot be sparse.\n",
            " |  \n",
            " |  partial_fit(self, X, y=None)\n",
            " |      Online computation of min and max on X for later scaling.\n",
            " |      All of X is processed as a single batch. This is intended for cases\n",
            " |      when `fit` is not feasible due to very large number of `n_samples`\n",
            " |      or because X is read from a continuous stream.\n",
            " |      \n",
            " |      Parameters\n",
            " |      ----------\n",
            " |      X : array-like, shape [n_samples, n_features]\n",
            " |          The data used to compute the mean and standard deviation\n",
            " |          used for later scaling along the features axis.\n",
            " |      \n",
            " |      y\n",
            " |          Ignored\n",
            " |  \n",
            " |  transform(self, X)\n",
            " |      Scaling features of X according to feature_range.\n",
            " |      \n",
            " |      Parameters\n",
            " |      ----------\n",
            " |      X : array-like, shape [n_samples, n_features]\n",
            " |          Input data that will be transformed.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Methods inherited from sklearn.base.BaseEstimator:\n",
            " |  \n",
            " |  __getstate__(self)\n",
            " |  \n",
            " |  __repr__(self, N_CHAR_MAX=700)\n",
            " |      Return repr(self).\n",
            " |  \n",
            " |  __setstate__(self, state)\n",
            " |  \n",
            " |  get_params(self, deep=True)\n",
            " |      Get parameters for this estimator.\n",
            " |      \n",
            " |      Parameters\n",
            " |      ----------\n",
            " |      deep : boolean, optional\n",
            " |          If True, will return the parameters for this estimator and\n",
            " |          contained subobjects that are estimators.\n",
            " |      \n",
            " |      Returns\n",
            " |      -------\n",
            " |      params : mapping of string to any\n",
            " |          Parameter names mapped to their values.\n",
            " |  \n",
            " |  set_params(self, **params)\n",
            " |      Set the parameters of this estimator.\n",
            " |      \n",
            " |      The method works on simple estimators as well as on nested objects\n",
            " |      (such as pipelines). The latter have parameters of the form\n",
            " |      ``<component>__<parameter>`` so that it's possible to update each\n",
            " |      component of a nested object.\n",
            " |      \n",
            " |      Returns\n",
            " |      -------\n",
            " |      self\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data descriptors inherited from sklearn.base.BaseEstimator:\n",
            " |  \n",
            " |  __dict__\n",
            " |      dictionary for instance variables (if defined)\n",
            " |  \n",
            " |  __weakref__\n",
            " |      list of weak references to the object (if defined)\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Methods inherited from sklearn.base.TransformerMixin:\n",
            " |  \n",
            " |  fit_transform(self, X, y=None, **fit_params)\n",
            " |      Fit to data, then transform it.\n",
            " |      \n",
            " |      Fits transformer to X and y with optional parameters fit_params\n",
            " |      and returns a transformed version of X.\n",
            " |      \n",
            " |      Parameters\n",
            " |      ----------\n",
            " |      X : numpy array of shape [n_samples, n_features]\n",
            " |          Training set.\n",
            " |      \n",
            " |      y : numpy array of shape [n_samples]\n",
            " |          Target values.\n",
            " |      \n",
            " |      Returns\n",
            " |      -------\n",
            " |      X_new : numpy array of shape [n_samples, n_features_new]\n",
            " |          Transformed array.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UiOazVu0bTGD"
      },
      "source": [
        "scaler = MinMaxScaler()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uo6rtNHtbTGH"
      },
      "source": [
        "# Notice to prevent data leakage from the test set, we only fit our scaler to the training set"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TsVBU5zPbTGL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6bae8dc4-7e93-4c9d-9472-bd367e8addfd"
      },
      "source": [
        "scaler.fit(X_train)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MinMaxScaler(copy=True, feature_range=(0, 1))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ShxZsxPebTGO"
      },
      "source": [
        "X_train = scaler.transform(X_train)\n",
        "X_test = scaler.transform(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CmA-6VkpbTGU"
      },
      "source": [
        "# TensorFlow 2.0 Syntax\n",
        "\n",
        "\n",
        "## Import Options\n",
        "\n",
        "There are several ways you can import Keras from Tensorflow (this is hugely a personal style choice, please use any import methods you prefer). We will use the method shown in the **official TF documentation**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NAS4I7MsbTGV"
      },
      "source": [
        "import tensorflow as tf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mVXx9_5bbTGZ"
      },
      "source": [
        "from tensorflow.keras.models import Sequential"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O8Oln8HsbTGc",
        "outputId": "9480d457-7139-41c9-f551-2b94b4fbef40"
      },
      "source": [
        "help(Sequential)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on class Sequential in module tensorflow.python.keras.engine.sequential:\n",
            "\n",
            "class Sequential(tensorflow.python.keras.engine.training.Model)\n",
            " |  Sequential(layers=None, name=None)\n",
            " |  \n",
            " |  Linear stack of layers.\n",
            " |  \n",
            " |  Arguments:\n",
            " |      layers: list of layers to add to the model.\n",
            " |  \n",
            " |  Example:\n",
            " |  \n",
            " |  ```python\n",
            " |  # Optionally, the first layer can receive an `input_shape` argument:\n",
            " |  model = Sequential()\n",
            " |  model.add(Dense(32, input_shape=(500,)))\n",
            " |  # Afterwards, we do automatic shape inference:\n",
            " |  model.add(Dense(32))\n",
            " |  \n",
            " |  # This is identical to the following:\n",
            " |  model = Sequential()\n",
            " |  model.add(Dense(32, input_dim=500))\n",
            " |  \n",
            " |  # And to the following:\n",
            " |  model = Sequential()\n",
            " |  model.add(Dense(32, batch_input_shape=(None, 500)))\n",
            " |  \n",
            " |  # Note that you can also omit the `input_shape` argument:\n",
            " |  # In that case the model gets built the first time you call `fit` (or other\n",
            " |  # training and evaluation methods).\n",
            " |  model = Sequential()\n",
            " |  model.add(Dense(32))\n",
            " |  model.add(Dense(32))\n",
            " |  model.compile(optimizer=optimizer, loss=loss)\n",
            " |  # This builds the model for the first time:\n",
            " |  model.fit(x, y, batch_size=32, epochs=10)\n",
            " |  \n",
            " |  # Note that when using this delayed-build pattern (no input shape specified),\n",
            " |  # the model doesn't have any weights until the first call\n",
            " |  # to a training/evaluation method (since it isn't yet built):\n",
            " |  model = Sequential()\n",
            " |  model.add(Dense(32))\n",
            " |  model.add(Dense(32))\n",
            " |  model.weights  # returns []\n",
            " |  \n",
            " |  # Whereas if you specify the input shape, the model gets built continuously\n",
            " |  # as you are adding layers:\n",
            " |  model = Sequential()\n",
            " |  model.add(Dense(32, input_shape=(500,)))\n",
            " |  model.add(Dense(32))\n",
            " |  model.weights  # returns list of length 4\n",
            " |  \n",
            " |  # When using the delayed-build pattern (no input shape specified), you can\n",
            " |  # choose to manually build your model by calling `build(batch_input_shape)`:\n",
            " |  model = Sequential()\n",
            " |  model.add(Dense(32))\n",
            " |  model.add(Dense(32))\n",
            " |  model.build((None, 500))\n",
            " |  model.weights  # returns list of length 4\n",
            " |  ```\n",
            " |  \n",
            " |  Method resolution order:\n",
            " |      Sequential\n",
            " |      tensorflow.python.keras.engine.training.Model\n",
            " |      tensorflow.python.keras.engine.network.Network\n",
            " |      tensorflow.python.keras.engine.base_layer.Layer\n",
            " |      tensorflow.python.module.module.Module\n",
            " |      tensorflow.python.training.tracking.tracking.AutoTrackable\n",
            " |      tensorflow.python.training.tracking.base.Trackable\n",
            " |      builtins.object\n",
            " |  \n",
            " |  Methods defined here:\n",
            " |  \n",
            " |  __init__(self, layers=None, name=None)\n",
            " |  \n",
            " |  add(self, layer)\n",
            " |      Adds a layer instance on top of the layer stack.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          layer: layer instance.\n",
            " |      \n",
            " |      Raises:\n",
            " |          TypeError: If `layer` is not a layer instance.\n",
            " |          ValueError: In case the `layer` argument does not\n",
            " |              know its input shape.\n",
            " |          ValueError: In case the `layer` argument has\n",
            " |              multiple output tensors, or is already connected\n",
            " |              somewhere else (forbidden in `Sequential` models).\n",
            " |  \n",
            " |  build(self, input_shape=None)\n",
            " |      Builds the model based on input shapes received.\n",
            " |      \n",
            " |      This is to be used for subclassed models, which do not know at instantiation\n",
            " |      time what their inputs look like.\n",
            " |      \n",
            " |      This method only exists for users who want to call `model.build()` in a\n",
            " |      standalone way (as a substitute for calling the model on real data to\n",
            " |      build it). It will never be called by the framework (and thus it will\n",
            " |      never throw unexpected errors in an unrelated workflow).\n",
            " |      \n",
            " |      Args:\n",
            " |       input_shape: Single tuple, TensorShape, or list of shapes, where shapes\n",
            " |           are tuples, integers, or TensorShapes.\n",
            " |      \n",
            " |      Raises:\n",
            " |        ValueError:\n",
            " |          1. In case of invalid user-provided data (not of type tuple,\n",
            " |             list, or TensorShape).\n",
            " |          2. If the model requires call arguments that are agnostic\n",
            " |             to the input shapes (positional or kwarg in call signature).\n",
            " |          3. If not all layers were properly built.\n",
            " |          4. If float type inputs are not supported within the layers.\n",
            " |      \n",
            " |        In each of these cases, the user should build their model by calling it\n",
            " |        on real tensor data.\n",
            " |  \n",
            " |  call(self, inputs, training=None, mask=None)\n",
            " |      Calls the model on new inputs.\n",
            " |      \n",
            " |      In this case `call` just reapplies\n",
            " |      all ops in the graph to the new inputs\n",
            " |      (e.g. build a new computational graph from the provided inputs).\n",
            " |      \n",
            " |      Arguments:\n",
            " |          inputs: A tensor or list of tensors.\n",
            " |          training: Boolean or boolean scalar tensor, indicating whether to run\n",
            " |            the `Network` in training mode or inference mode.\n",
            " |          mask: A mask or list of masks. A mask can be\n",
            " |              either a tensor or None (no mask).\n",
            " |      \n",
            " |      Returns:\n",
            " |          A tensor if there is a single output, or\n",
            " |          a list of tensors if there are more than one outputs.\n",
            " |  \n",
            " |  compute_mask(self, inputs, mask)\n",
            " |      Computes an output mask tensor.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          inputs: Tensor or list of tensors.\n",
            " |          mask: Tensor or list of tensors.\n",
            " |      \n",
            " |      Returns:\n",
            " |          None or a tensor (or list of tensors,\n",
            " |              one per output tensor of the layer).\n",
            " |  \n",
            " |  compute_output_shape(self, input_shape)\n",
            " |      Computes the output shape of the layer.\n",
            " |      \n",
            " |      If the layer has not been built, this method will call `build` on the\n",
            " |      layer. This assumes that the layer will later be used with inputs that\n",
            " |      match the input shape provided here.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          input_shape: Shape tuple (tuple of integers)\n",
            " |              or list of shape tuples (one per output tensor of the layer).\n",
            " |              Shape tuples can include None for free dimensions,\n",
            " |              instead of an integer.\n",
            " |      \n",
            " |      Returns:\n",
            " |          An input shape tuple.\n",
            " |  \n",
            " |  get_config(self)\n",
            " |      Returns the config of the layer.\n",
            " |      \n",
            " |      A layer config is a Python dictionary (serializable)\n",
            " |      containing the configuration of a layer.\n",
            " |      The same layer can be reinstantiated later\n",
            " |      (without its trained weights) from this configuration.\n",
            " |      \n",
            " |      The config of a layer does not include connectivity\n",
            " |      information, nor the layer class name. These are handled\n",
            " |      by `Network` (one layer of abstraction above).\n",
            " |      \n",
            " |      Returns:\n",
            " |          Python dictionary.\n",
            " |  \n",
            " |  pop(self)\n",
            " |      Removes the last layer in the model.\n",
            " |      \n",
            " |      Raises:\n",
            " |          TypeError: if there are no layers in the model.\n",
            " |  \n",
            " |  predict_classes(self, x, batch_size=32, verbose=0)\n",
            " |      Generate class predictions for the input samples.\n",
            " |      \n",
            " |      The input samples are processed batch by batch.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          x: input data, as a Numpy array or list of Numpy arrays\n",
            " |              (if the model has multiple inputs).\n",
            " |          batch_size: integer.\n",
            " |          verbose: verbosity mode, 0 or 1.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A numpy array of class predictions.\n",
            " |  \n",
            " |  predict_proba(self, x, batch_size=32, verbose=0)\n",
            " |      Generates class probability predictions for the input samples.\n",
            " |      \n",
            " |      The input samples are processed batch by batch.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          x: input data, as a Numpy array or list of Numpy arrays\n",
            " |              (if the model has multiple inputs).\n",
            " |          batch_size: integer.\n",
            " |          verbose: verbosity mode, 0 or 1.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A Numpy array of probability predictions.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Class methods defined here:\n",
            " |  \n",
            " |  from_config(config, custom_objects=None) from builtins.type\n",
            " |      Instantiates a Model from its config (output of `get_config()`).\n",
            " |      \n",
            " |      Arguments:\n",
            " |          config: Model config dictionary.\n",
            " |          custom_objects: Optional dictionary mapping names\n",
            " |              (strings) to custom classes or functions to be\n",
            " |              considered during deserialization.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A model instance.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: In case of improperly formatted config dict.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data descriptors defined here:\n",
            " |  \n",
            " |  dynamic\n",
            " |  \n",
            " |  input_spec\n",
            " |      Gets the network's input specs.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A list of `InputSpec` instances (one per input to the model)\n",
            " |              or a single instance if the model has only one input.\n",
            " |  \n",
            " |  layers\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Methods inherited from tensorflow.python.keras.engine.training.Model:\n",
            " |  \n",
            " |  compile(self, optimizer='rmsprop', loss=None, metrics=None, loss_weights=None, sample_weight_mode=None, weighted_metrics=None, target_tensors=None, distribute=None, **kwargs)\n",
            " |      Configures the model for training.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          optimizer: String (name of optimizer) or optimizer instance.\n",
            " |              See `tf.keras.optimizers`.\n",
            " |          loss: String (name of objective function), objective function or\n",
            " |              `tf.losses.Loss` instance. See `tf.losses`. If the model has\n",
            " |              multiple outputs, you can use a different loss on each output by\n",
            " |              passing a dictionary or a list of losses. The loss value that will\n",
            " |              be minimized by the model will then be the sum of all individual\n",
            " |              losses.\n",
            " |          metrics: List of metrics to be evaluated by the model during training\n",
            " |              and testing. Typically you will use `metrics=['accuracy']`.\n",
            " |              To specify different metrics for different outputs of a\n",
            " |              multi-output model, you could also pass a dictionary, such as\n",
            " |              `metrics={'output_a': 'accuracy', 'output_b': ['accuracy', 'mse']}`.\n",
            " |              You can also pass a list (len = len(outputs)) of lists of metrics\n",
            " |              such as `metrics=[['accuracy'], ['accuracy', 'mse']]` or\n",
            " |              `metrics=['accuracy', ['accuracy', 'mse']]`.\n",
            " |          loss_weights: Optional list or dictionary specifying scalar\n",
            " |              coefficients (Python floats) to weight the loss contributions\n",
            " |              of different model outputs.\n",
            " |              The loss value that will be minimized by the model\n",
            " |              will then be the *weighted sum* of all individual losses,\n",
            " |              weighted by the `loss_weights` coefficients.\n",
            " |              If a list, it is expected to have a 1:1 mapping\n",
            " |              to the model's outputs. If a tensor, it is expected to map\n",
            " |              output names (strings) to scalar coefficients.\n",
            " |          sample_weight_mode: If you need to do timestep-wise\n",
            " |              sample weighting (2D weights), set this to `\"temporal\"`.\n",
            " |              `None` defaults to sample-wise weights (1D).\n",
            " |              If the model has multiple outputs, you can use a different\n",
            " |              `sample_weight_mode` on each output by passing a\n",
            " |              dictionary or a list of modes.\n",
            " |          weighted_metrics: List of metrics to be evaluated and weighted\n",
            " |              by sample_weight or class_weight during training and testing.\n",
            " |          target_tensors: By default, Keras will create placeholders for the\n",
            " |              model's target, which will be fed with the target data during\n",
            " |              training. If instead you would like to use your own\n",
            " |              target tensors (in turn, Keras will not expect external\n",
            " |              Numpy data for these targets at training time), you\n",
            " |              can specify them via the `target_tensors` argument. It can be\n",
            " |              a single tensor (for a single-output model), a list of tensors,\n",
            " |              or a dict mapping output names to target tensors.\n",
            " |          distribute: NOT SUPPORTED IN TF 2.0, please create and compile the\n",
            " |              model under distribution strategy scope instead of passing it to\n",
            " |              compile.\n",
            " |          **kwargs: Any additional arguments.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: In case of invalid arguments for\n",
            " |              `optimizer`, `loss`, `metrics` or `sample_weight_mode`.\n",
            " |  \n",
            " |  evaluate(self, x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False)\n",
            " |      Returns the loss value & metrics values for the model in test mode.\n",
            " |      \n",
            " |      Computation is done in batches.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          x: Input data. It could be:\n",
            " |            - A Numpy array (or array-like), or a list of arrays\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A TensorFlow tensor, or a list of tensors\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A dict mapping input names to the corresponding array/tensors,\n",
            " |              if the model has named inputs.\n",
            " |            - A `tf.data` dataset.\n",
            " |            - A generator or `keras.utils.Sequence` instance.\n",
            " |          y: Target data. Like the input data `x`,\n",
            " |            it could be either Numpy array(s) or TensorFlow tensor(s).\n",
            " |            It should be consistent with `x` (you cannot have Numpy inputs and\n",
            " |            tensor targets, or inversely).\n",
            " |            If `x` is a dataset, generator or\n",
            " |            `keras.utils.Sequence` instance, `y` should not be specified (since\n",
            " |            targets will be obtained from the iterator/dataset).\n",
            " |          batch_size: Integer or `None`.\n",
            " |              Number of samples per gradient update.\n",
            " |              If unspecified, `batch_size` will default to 32.\n",
            " |              Do not specify the `batch_size` is your data is in the\n",
            " |              form of symbolic tensors, dataset,\n",
            " |              generators, or `keras.utils.Sequence` instances (since they generate\n",
            " |              batches).\n",
            " |          verbose: 0 or 1. Verbosity mode.\n",
            " |              0 = silent, 1 = progress bar.\n",
            " |          sample_weight: Optional Numpy array of weights for\n",
            " |              the test samples, used for weighting the loss function.\n",
            " |              You can either pass a flat (1D)\n",
            " |              Numpy array with the same length as the input samples\n",
            " |              (1:1 mapping between weights and samples),\n",
            " |              or in the case of temporal data,\n",
            " |              you can pass a 2D array with shape\n",
            " |              `(samples, sequence_length)`,\n",
            " |              to apply a different weight to every timestep of every sample.\n",
            " |              In this case you should make sure to specify\n",
            " |              `sample_weight_mode=\"temporal\"` in `compile()`. This argument is not\n",
            " |              supported when `x` is a dataset, instead pass\n",
            " |              sample weights as the third element of `x`.\n",
            " |          steps: Integer or `None`.\n",
            " |              Total number of steps (batches of samples)\n",
            " |              before declaring the evaluation round finished.\n",
            " |              Ignored with the default value of `None`.\n",
            " |              If x is a `tf.data` dataset and `steps` is\n",
            " |              None, 'evaluate' will run until the dataset is exhausted.\n",
            " |              This argument is not supported with array inputs.\n",
            " |          callbacks: List of `keras.callbacks.Callback` instances.\n",
            " |              List of callbacks to apply during evaluation.\n",
            " |              See [callbacks](/api_docs/python/tf/keras/callbacks).\n",
            " |          max_queue_size: Integer. Used for generator or `keras.utils.Sequence`\n",
            " |              input only. Maximum size for the generator queue.\n",
            " |              If unspecified, `max_queue_size` will default to 10.\n",
            " |          workers: Integer. Used for generator or `keras.utils.Sequence` input\n",
            " |              only. Maximum number of processes to spin up when using\n",
            " |              process-based threading. If unspecified, `workers` will default\n",
            " |              to 1. If 0, will execute the generator on the main thread.\n",
            " |          use_multiprocessing: Boolean. Used for generator or\n",
            " |              `keras.utils.Sequence` input only. If `True`, use process-based\n",
            " |              threading. If unspecified, `use_multiprocessing` will default to\n",
            " |              `False`. Note that because this implementation relies on\n",
            " |              multiprocessing, you should not pass non-picklable arguments to\n",
            " |              the generator as they can't be passed easily to children processes.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Scalar test loss (if the model has a single output and no metrics)\n",
            " |          or list of scalars (if the model has multiple outputs\n",
            " |          and/or metrics). The attribute `model.metrics_names` will give you\n",
            " |          the display labels for the scalar outputs.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: in case of invalid arguments.\n",
            " |  \n",
            " |  evaluate_generator(self, generator, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False, verbose=0)\n",
            " |      Evaluates the model on a data generator.\n",
            " |      \n",
            " |      The generator should return the same kind of data\n",
            " |      as accepted by `test_on_batch`.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          generator: Generator yielding tuples (inputs, targets)\n",
            " |              or (inputs, targets, sample_weights)\n",
            " |              or an instance of `keras.utils.Sequence`\n",
            " |              object in order to avoid duplicate data\n",
            " |              when using multiprocessing.\n",
            " |          steps: Total number of steps (batches of samples)\n",
            " |              to yield from `generator` before stopping.\n",
            " |              Optional for `Sequence`: if unspecified, will use\n",
            " |              the `len(generator)` as a number of steps.\n",
            " |          callbacks: List of `keras.callbacks.Callback` instances.\n",
            " |              List of callbacks to apply during evaluation.\n",
            " |              See [callbacks](/api_docs/python/tf/keras/callbacks).\n",
            " |          max_queue_size: maximum size for the generator queue\n",
            " |          workers: Integer. Maximum number of processes to spin up\n",
            " |              when using process-based threading.\n",
            " |              If unspecified, `workers` will default to 1. If 0, will\n",
            " |              execute the generator on the main thread.\n",
            " |          use_multiprocessing: Boolean.\n",
            " |              If `True`, use process-based threading.\n",
            " |              If unspecified, `use_multiprocessing` will default to `False`.\n",
            " |              Note that because this implementation relies on multiprocessing,\n",
            " |              you should not pass non-picklable arguments to the generator\n",
            " |              as they can't be passed easily to children processes.\n",
            " |          verbose: Verbosity mode, 0 or 1.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Scalar test loss (if the model has a single output and no metrics)\n",
            " |          or list of scalars (if the model has multiple outputs\n",
            " |          and/or metrics). The attribute `model.metrics_names` will give you\n",
            " |          the display labels for the scalar outputs.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: in case of invalid arguments.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: In case the generator yields data in an invalid format.\n",
            " |  \n",
            " |  fit(self, x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None, validation_split=0.0, validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_freq=1, max_queue_size=10, workers=1, use_multiprocessing=False, **kwargs)\n",
            " |      Trains the model for a fixed number of epochs (iterations on a dataset).\n",
            " |      \n",
            " |      Arguments:\n",
            " |          x: Input data. It could be:\n",
            " |            - A Numpy array (or array-like), or a list of arrays\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A TensorFlow tensor, or a list of tensors\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A dict mapping input names to the corresponding array/tensors,\n",
            " |              if the model has named inputs.\n",
            " |            - A `tf.data` dataset. Should return a tuple\n",
            " |              of either `(inputs, targets)` or\n",
            " |              `(inputs, targets, sample_weights)`.\n",
            " |            - A generator or `keras.utils.Sequence` returning `(inputs, targets)`\n",
            " |              or `(inputs, targets, sample weights)`.\n",
            " |          y: Target data. Like the input data `x`,\n",
            " |            it could be either Numpy array(s) or TensorFlow tensor(s).\n",
            " |            It should be consistent with `x` (you cannot have Numpy inputs and\n",
            " |            tensor targets, or inversely). If `x` is a dataset, generator,\n",
            " |            or `keras.utils.Sequence` instance, `y` should\n",
            " |            not be specified (since targets will be obtained from `x`).\n",
            " |          batch_size: Integer or `None`.\n",
            " |              Number of samples per gradient update.\n",
            " |              If unspecified, `batch_size` will default to 32.\n",
            " |              Do not specify the `batch_size` if your data is in the\n",
            " |              form of symbolic tensors, datasets,\n",
            " |              generators, or `keras.utils.Sequence` instances (since they generate\n",
            " |              batches).\n",
            " |          epochs: Integer. Number of epochs to train the model.\n",
            " |              An epoch is an iteration over the entire `x` and `y`\n",
            " |              data provided.\n",
            " |              Note that in conjunction with `initial_epoch`,\n",
            " |              `epochs` is to be understood as \"final epoch\".\n",
            " |              The model is not trained for a number of iterations\n",
            " |              given by `epochs`, but merely until the epoch\n",
            " |              of index `epochs` is reached.\n",
            " |          verbose: 0, 1, or 2. Verbosity mode.\n",
            " |              0 = silent, 1 = progress bar, 2 = one line per epoch.\n",
            " |              Note that the progress bar is not particularly useful when\n",
            " |              logged to a file, so verbose=2 is recommended when not running\n",
            " |              interactively (eg, in a production environment).\n",
            " |          callbacks: List of `keras.callbacks.Callback` instances.\n",
            " |              List of callbacks to apply during training.\n",
            " |              See `tf.keras.callbacks`.\n",
            " |          validation_split: Float between 0 and 1.\n",
            " |              Fraction of the training data to be used as validation data.\n",
            " |              The model will set apart this fraction of the training data,\n",
            " |              will not train on it, and will evaluate\n",
            " |              the loss and any model metrics\n",
            " |              on this data at the end of each epoch.\n",
            " |              The validation data is selected from the last samples\n",
            " |              in the `x` and `y` data provided, before shuffling. This argument is\n",
            " |              not supported when `x` is a dataset, generator or\n",
            " |             `keras.utils.Sequence` instance.\n",
            " |          validation_data: Data on which to evaluate\n",
            " |              the loss and any model metrics at the end of each epoch.\n",
            " |              The model will not be trained on this data.\n",
            " |              `validation_data` will override `validation_split`.\n",
            " |              `validation_data` could be:\n",
            " |                - tuple `(x_val, y_val)` of Numpy arrays or tensors\n",
            " |                - tuple `(x_val, y_val, val_sample_weights)` of Numpy arrays\n",
            " |                - dataset\n",
            " |              For the first two cases, `batch_size` must be provided.\n",
            " |              For the last case, `validation_steps` must be provided.\n",
            " |          shuffle: Boolean (whether to shuffle the training data\n",
            " |              before each epoch) or str (for 'batch').\n",
            " |              'batch' is a special option for dealing with the\n",
            " |              limitations of HDF5 data; it shuffles in batch-sized chunks.\n",
            " |              Has no effect when `steps_per_epoch` is not `None`.\n",
            " |          class_weight: Optional dictionary mapping class indices (integers)\n",
            " |              to a weight (float) value, used for weighting the loss function\n",
            " |              (during training only).\n",
            " |              This can be useful to tell the model to\n",
            " |              \"pay more attention\" to samples from\n",
            " |              an under-represented class.\n",
            " |          sample_weight: Optional Numpy array of weights for\n",
            " |              the training samples, used for weighting the loss function\n",
            " |              (during training only). You can either pass a flat (1D)\n",
            " |              Numpy array with the same length as the input samples\n",
            " |              (1:1 mapping between weights and samples),\n",
            " |              or in the case of temporal data,\n",
            " |              you can pass a 2D array with shape\n",
            " |              `(samples, sequence_length)`,\n",
            " |              to apply a different weight to every timestep of every sample.\n",
            " |              In this case you should make sure to specify\n",
            " |              `sample_weight_mode=\"temporal\"` in `compile()`. This argument is not\n",
            " |              supported when `x` is a dataset, generator, or\n",
            " |             `keras.utils.Sequence` instance, instead provide the sample_weights\n",
            " |              as the third element of `x`.\n",
            " |          initial_epoch: Integer.\n",
            " |              Epoch at which to start training\n",
            " |              (useful for resuming a previous training run).\n",
            " |          steps_per_epoch: Integer or `None`.\n",
            " |              Total number of steps (batches of samples)\n",
            " |              before declaring one epoch finished and starting the\n",
            " |              next epoch. When training with input tensors such as\n",
            " |              TensorFlow data tensors, the default `None` is equal to\n",
            " |              the number of samples in your dataset divided by\n",
            " |              the batch size, or 1 if that cannot be determined. If x is a\n",
            " |              `tf.data` dataset, and 'steps_per_epoch'\n",
            " |              is None, the epoch will run until the input dataset is exhausted.\n",
            " |              This argument is not supported with array inputs.\n",
            " |          validation_steps: Only relevant if `validation_data` is provided and\n",
            " |              is a `tf.data` dataset. Total number of steps (batches of\n",
            " |              samples) to draw before stopping when performing validation\n",
            " |              at the end of every epoch. If validation_data is a `tf.data` dataset\n",
            " |              and 'validation_steps' is None, validation\n",
            " |              will run until the `validation_data` dataset is exhausted.\n",
            " |          validation_freq: Only relevant if validation data is provided. Integer\n",
            " |              or `collections_abc.Container` instance (e.g. list, tuple, etc.).\n",
            " |              If an integer, specifies how many training epochs to run before a\n",
            " |              new validation run is performed, e.g. `validation_freq=2` runs\n",
            " |              validation every 2 epochs. If a Container, specifies the epochs on\n",
            " |              which to run validation, e.g. `validation_freq=[1, 2, 10]` runs\n",
            " |              validation at the end of the 1st, 2nd, and 10th epochs.\n",
            " |          max_queue_size: Integer. Used for generator or `keras.utils.Sequence`\n",
            " |              input only. Maximum size for the generator queue.\n",
            " |              If unspecified, `max_queue_size` will default to 10.\n",
            " |          workers: Integer. Used for generator or `keras.utils.Sequence` input\n",
            " |              only. Maximum number of processes to spin up\n",
            " |              when using process-based threading. If unspecified, `workers`\n",
            " |              will default to 1. If 0, will execute the generator on the main\n",
            " |              thread.\n",
            " |          use_multiprocessing: Boolean. Used for generator or\n",
            " |              `keras.utils.Sequence` input only. If `True`, use process-based\n",
            " |              threading. If unspecified, `use_multiprocessing` will default to\n",
            " |              `False`. Note that because this implementation relies on\n",
            " |              multiprocessing, you should not pass non-picklable arguments to\n",
            " |              the generator as they can't be passed easily to children processes.\n",
            " |          **kwargs: Used for backwards compatibility.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A `History` object. Its `History.history` attribute is\n",
            " |          a record of training loss values and metrics values\n",
            " |          at successive epochs, as well as validation loss values\n",
            " |          and validation metrics values (if applicable).\n",
            " |      \n",
            " |      Raises:\n",
            " |          RuntimeError: If the model was never compiled.\n",
            " |          ValueError: In case of mismatch between the provided input data\n",
            " |              and what the model expects.\n",
            " |  \n",
            " |  fit_generator(self, generator, steps_per_epoch=None, epochs=1, verbose=1, callbacks=None, validation_data=None, validation_steps=None, validation_freq=1, class_weight=None, max_queue_size=10, workers=1, use_multiprocessing=False, shuffle=True, initial_epoch=0)\n",
            " |      Fits the model on data yielded batch-by-batch by a Python generator.\n",
            " |      \n",
            " |      The generator is run in parallel to the model, for efficiency.\n",
            " |      For instance, this allows you to do real-time data augmentation\n",
            " |      on images on CPU in parallel to training your model on GPU.\n",
            " |      \n",
            " |      The use of `keras.utils.Sequence` guarantees the ordering\n",
            " |      and guarantees the single use of every input per epoch when\n",
            " |      using `use_multiprocessing=True`.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          generator: A generator or an instance of `Sequence`\n",
            " |            (`keras.utils.Sequence`)\n",
            " |              object in order to avoid duplicate data\n",
            " |              when using multiprocessing.\n",
            " |              The output of the generator must be either\n",
            " |              - a tuple `(inputs, targets)`\n",
            " |              - a tuple `(inputs, targets, sample_weights)`.\n",
            " |              This tuple (a single output of the generator) makes a single batch.\n",
            " |              Therefore, all arrays in this tuple must have the same length (equal\n",
            " |              to the size of this batch). Different batches may have different\n",
            " |                sizes.\n",
            " |              For example, the last batch of the epoch is commonly smaller than\n",
            " |                the\n",
            " |              others, if the size of the dataset is not divisible by the batch\n",
            " |                size.\n",
            " |              The generator is expected to loop over its data\n",
            " |              indefinitely. An epoch finishes when `steps_per_epoch`\n",
            " |              batches have been seen by the model.\n",
            " |          steps_per_epoch: Total number of steps (batches of samples)\n",
            " |              to yield from `generator` before declaring one epoch\n",
            " |              finished and starting the next epoch. It should typically\n",
            " |              be equal to the number of samples of your dataset\n",
            " |              divided by the batch size.\n",
            " |              Optional for `Sequence`: if unspecified, will use\n",
            " |              the `len(generator)` as a number of steps.\n",
            " |          epochs: Integer, total number of iterations on the data.\n",
            " |          verbose: Verbosity mode, 0, 1, or 2.\n",
            " |          callbacks: List of callbacks to be called during training.\n",
            " |          validation_data: This can be either\n",
            " |              - a generator for the validation data\n",
            " |              - a tuple (inputs, targets)\n",
            " |              - a tuple (inputs, targets, sample_weights).\n",
            " |          validation_steps: Only relevant if `validation_data`\n",
            " |              is a generator. Total number of steps (batches of samples)\n",
            " |              to yield from `generator` before stopping.\n",
            " |              Optional for `Sequence`: if unspecified, will use\n",
            " |              the `len(validation_data)` as a number of steps.\n",
            " |          validation_freq: Only relevant if validation data is provided. Integer\n",
            " |              or `collections_abc.Container` instance (e.g. list, tuple, etc.).\n",
            " |              If an integer, specifies how many training epochs to run before a\n",
            " |              new validation run is performed, e.g. `validation_freq=2` runs\n",
            " |              validation every 2 epochs. If a Container, specifies the epochs on\n",
            " |              which to run validation, e.g. `validation_freq=[1, 2, 10]` runs\n",
            " |              validation at the end of the 1st, 2nd, and 10th epochs.\n",
            " |          class_weight: Dictionary mapping class indices to a weight\n",
            " |              for the class.\n",
            " |          max_queue_size: Integer. Maximum size for the generator queue.\n",
            " |              If unspecified, `max_queue_size` will default to 10.\n",
            " |          workers: Integer. Maximum number of processes to spin up\n",
            " |              when using process-based threading.\n",
            " |              If unspecified, `workers` will default to 1. If 0, will\n",
            " |              execute the generator on the main thread.\n",
            " |          use_multiprocessing: Boolean.\n",
            " |              If `True`, use process-based threading.\n",
            " |              If unspecified, `use_multiprocessing` will default to `False`.\n",
            " |              Note that because this implementation relies on multiprocessing,\n",
            " |              you should not pass non-picklable arguments to the generator\n",
            " |              as they can't be passed easily to children processes.\n",
            " |          shuffle: Boolean. Whether to shuffle the order of the batches at\n",
            " |              the beginning of each epoch. Only used with instances\n",
            " |              of `Sequence` (`keras.utils.Sequence`).\n",
            " |              Has no effect when `steps_per_epoch` is not `None`.\n",
            " |          initial_epoch: Epoch at which to start training\n",
            " |              (useful for resuming a previous training run)\n",
            " |      \n",
            " |      Returns:\n",
            " |          A `History` object.\n",
            " |      \n",
            " |      Example:\n",
            " |      \n",
            " |      ```python\n",
            " |          def generate_arrays_from_file(path):\n",
            " |              while 1:\n",
            " |                  f = open(path)\n",
            " |                  for line in f:\n",
            " |                      # create numpy arrays of input data\n",
            " |                      # and labels, from each line in the file\n",
            " |                      x1, x2, y = process_line(line)\n",
            " |                      yield ({'input_1': x1, 'input_2': x2}, {'output': y})\n",
            " |                  f.close()\n",
            " |      \n",
            " |          model.fit_generator(generate_arrays_from_file('/my_file.txt'),\n",
            " |                              steps_per_epoch=10000, epochs=10)\n",
            " |      ```\n",
            " |      Raises:\n",
            " |          ValueError: In case the generator yields data in an invalid format.\n",
            " |  \n",
            " |  get_weights(self)\n",
            " |      Retrieves the weights of the model.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A flat list of Numpy arrays.\n",
            " |  \n",
            " |  load_weights(self, filepath, by_name=False)\n",
            " |      Loads all layer weights, either from a TensorFlow or an HDF5 file.\n",
            " |  \n",
            " |  predict(self, x, batch_size=None, verbose=0, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False)\n",
            " |      Generates output predictions for the input samples.\n",
            " |      \n",
            " |      Computation is done in batches.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          x: Input samples. It could be:\n",
            " |            - A Numpy array (or array-like), or a list of arrays\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A TensorFlow tensor, or a list of tensors\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A `tf.data` dataset.\n",
            " |            - A generator or `keras.utils.Sequence` instance.\n",
            " |          batch_size: Integer or `None`.\n",
            " |              Number of samples per gradient update.\n",
            " |              If unspecified, `batch_size` will default to 32.\n",
            " |              Do not specify the `batch_size` is your data is in the\n",
            " |              form of symbolic tensors, dataset,\n",
            " |              generators, or `keras.utils.Sequence` instances (since they generate\n",
            " |              batches).\n",
            " |          verbose: Verbosity mode, 0 or 1.\n",
            " |          steps: Total number of steps (batches of samples)\n",
            " |              before declaring the prediction round finished.\n",
            " |              Ignored with the default value of `None`. If x is a `tf.data`\n",
            " |              dataset and `steps` is None, `predict` will\n",
            " |              run until the input dataset is exhausted.\n",
            " |          callbacks: List of `keras.callbacks.Callback` instances.\n",
            " |              List of callbacks to apply during prediction.\n",
            " |              See [callbacks](/api_docs/python/tf/keras/callbacks).\n",
            " |          max_queue_size: Integer. Used for generator or `keras.utils.Sequence`\n",
            " |              input only. Maximum size for the generator queue.\n",
            " |              If unspecified, `max_queue_size` will default to 10.\n",
            " |          workers: Integer. Used for generator or `keras.utils.Sequence` input\n",
            " |              only. Maximum number of processes to spin up when using\n",
            " |              process-based threading. If unspecified, `workers` will default\n",
            " |              to 1. If 0, will execute the generator on the main thread.\n",
            " |          use_multiprocessing: Boolean. Used for generator or\n",
            " |              `keras.utils.Sequence` input only. If `True`, use process-based\n",
            " |              threading. If unspecified, `use_multiprocessing` will default to\n",
            " |              `False`. Note that because this implementation relies on\n",
            " |              multiprocessing, you should not pass non-picklable arguments to\n",
            " |              the generator as they can't be passed easily to children processes.\n",
            " |      \n",
            " |      \n",
            " |      Returns:\n",
            " |          Numpy array(s) of predictions.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: In case of mismatch between the provided\n",
            " |              input data and the model's expectations,\n",
            " |              or in case a stateful model receives a number of samples\n",
            " |              that is not a multiple of the batch size.\n",
            " |  \n",
            " |  predict_generator(self, generator, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False, verbose=0)\n",
            " |      Generates predictions for the input samples from a data generator.\n",
            " |      \n",
            " |      The generator should return the same kind of data as accepted by\n",
            " |      `predict_on_batch`.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          generator: Generator yielding batches of input samples\n",
            " |              or an instance of `keras.utils.Sequence` object in order to\n",
            " |              avoid duplicate data when using multiprocessing.\n",
            " |          steps: Total number of steps (batches of samples)\n",
            " |              to yield from `generator` before stopping.\n",
            " |              Optional for `Sequence`: if unspecified, will use\n",
            " |              the `len(generator)` as a number of steps.\n",
            " |          callbacks: List of `keras.callbacks.Callback` instances.\n",
            " |              List of callbacks to apply during prediction.\n",
            " |              See [callbacks](/api_docs/python/tf/keras/callbacks).\n",
            " |          max_queue_size: Maximum size for the generator queue.\n",
            " |          workers: Integer. Maximum number of processes to spin up\n",
            " |              when using process-based threading.\n",
            " |              If unspecified, `workers` will default to 1. If 0, will\n",
            " |              execute the generator on the main thread.\n",
            " |          use_multiprocessing: Boolean.\n",
            " |              If `True`, use process-based threading.\n",
            " |              If unspecified, `use_multiprocessing` will default to `False`.\n",
            " |              Note that because this implementation relies on multiprocessing,\n",
            " |              you should not pass non-picklable arguments to the generator\n",
            " |              as they can't be passed easily to children processes.\n",
            " |          verbose: verbosity mode, 0 or 1.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Numpy array(s) of predictions.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: In case the generator yields data in an invalid format.\n",
            " |  \n",
            " |  predict_on_batch(self, x)\n",
            " |      Returns predictions for a single batch of samples.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          x: Input data. It could be:\n",
            " |            - A Numpy array (or array-like), or a list of arrays\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A TensorFlow tensor, or a list of tensors\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A `tf.data` dataset.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Numpy array(s) of predictions.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: In case of mismatch between given number of inputs and\n",
            " |            expectations of the model.\n",
            " |  \n",
            " |  reset_metrics(self)\n",
            " |      Resets the state of metrics.\n",
            " |  \n",
            " |  test_on_batch(self, x, y=None, sample_weight=None, reset_metrics=True)\n",
            " |      Test the model on a single batch of samples.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          x: Input data. It could be:\n",
            " |            - A Numpy array (or array-like), or a list of arrays\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A TensorFlow tensor, or a list of tensors\n",
            " |              (in case the model has multiple inputs).\n",
            " |            - A dict mapping input names to the corresponding array/tensors,\n",
            " |              if the model has named inputs.\n",
            " |            - A `tf.data` dataset.\n",
            " |          y: Target data. Like the input data `x`,\n",
            " |            it could be either Numpy array(s) or TensorFlow tensor(s).\n",
            " |            It should be consistent with `x` (you cannot have Numpy inputs and\n",
            " |            tensor targets, or inversely). If `x` is a dataset `y` should\n",
            " |            not be specified (since targets will be obtained from the iterator).\n",
            " |          sample_weight: Optional array of the same length as x, containing\n",
            " |              weights to apply to the model's loss for each sample.\n",
            " |              In the case of temporal data, you can pass a 2D array\n",
            " |              with shape (samples, sequence_length),\n",
            " |              to apply a different weight to every timestep of every sample.\n",
            " |              In this case you should make sure to specify\n",
            " |              sample_weight_mode=\"temporal\" in compile(). This argument is not\n",
            " |              supported when `x` is a dataset.\n",
            " |          reset_metrics: If `True`, the metrics returned will be only for this\n",
            " |            batch. If `False`, the metrics will be statefully accumulated across\n",
            " |            batches.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Scalar test loss (if the model has a single output and no metrics)\n",
            " |          or list of scalars (if the model has multiple outputs\n",
            " |          and/or metrics). The attribute `model.metrics_names` will give you\n",
            " |          the display labels for the scalar outputs.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: In case of invalid user-provided arguments.\n",
            " |  \n",
            " |  train_on_batch(self, x, y=None, sample_weight=None, class_weight=None, reset_metrics=True)\n",
            " |      Runs a single gradient update on a single batch of data.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          x: Input data. It could be:\n",
            " |            - A Numpy array (or array-like), or a list of arrays\n",
            " |                (in case the model has multiple inputs).\n",
            " |            - A TensorFlow tensor, or a list of tensors\n",
            " |                (in case the model has multiple inputs).\n",
            " |            - A dict mapping input names to the corresponding array/tensors,\n",
            " |                if the model has named inputs.\n",
            " |            - A `tf.data` dataset.\n",
            " |          y: Target data. Like the input data `x`, it could be either Numpy\n",
            " |            array(s) or TensorFlow tensor(s). It should be consistent with `x`\n",
            " |            (you cannot have Numpy inputs and tensor targets, or inversely). If\n",
            " |            `x` is a dataset, `y` should not be specified\n",
            " |            (since targets will be obtained from the iterator).\n",
            " |          sample_weight: Optional array of the same length as x, containing\n",
            " |            weights to apply to the model's loss for each sample. In the case of\n",
            " |            temporal data, you can pass a 2D array with shape (samples,\n",
            " |            sequence_length), to apply a different weight to every timestep of\n",
            " |            every sample. In this case you should make sure to specify\n",
            " |            sample_weight_mode=\"temporal\" in compile(). This argument is not\n",
            " |            supported when `x` is a dataset.\n",
            " |          class_weight: Optional dictionary mapping class indices (integers) to a\n",
            " |            weight (float) to apply to the model's loss for the samples from this\n",
            " |            class during training. This can be useful to tell the model to \"pay\n",
            " |            more attention\" to samples from an under-represented class.\n",
            " |          reset_metrics: If `True`, the metrics returned will be only for this\n",
            " |            batch. If `False`, the metrics will be statefully accumulated across\n",
            " |            batches.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Scalar training loss\n",
            " |          (if the model has a single output and no metrics)\n",
            " |          or list of scalars (if the model has multiple outputs\n",
            " |          and/or metrics). The attribute `model.metrics_names` will give you\n",
            " |          the display labels for the scalar outputs.\n",
            " |      \n",
            " |      Raises:\n",
            " |        ValueError: In case of invalid user-provided arguments.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data descriptors inherited from tensorflow.python.keras.engine.training.Model:\n",
            " |  \n",
            " |  metrics\n",
            " |      Returns the model's metrics added using `compile`, `add_metric` APIs.\n",
            " |  \n",
            " |  metrics_names\n",
            " |      Returns the model's display labels for all outputs.\n",
            " |  \n",
            " |  run_eagerly\n",
            " |      Settable attribute indicating whether the model should run eagerly.\n",
            " |      \n",
            " |      Running eagerly means that your model will be run step by step,\n",
            " |      like Python code. Your model might run slower, but it should become easier\n",
            " |      for you to debug it by stepping into individual layer calls.\n",
            " |      \n",
            " |      By default, we will attempt to compile your model to a static graph to\n",
            " |      deliver the best execution performance.\n",
            " |      \n",
            " |      Returns:\n",
            " |        Boolean, whether the model should run eagerly.\n",
            " |  \n",
            " |  sample_weights\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Methods inherited from tensorflow.python.keras.engine.network.Network:\n",
            " |  \n",
            " |  __setattr__(self, name, value)\n",
            " |      Support self.foo = trackable syntax.\n",
            " |  \n",
            " |  get_layer(self, name=None, index=None)\n",
            " |      Retrieves a layer based on either its name (unique) or index.\n",
            " |      \n",
            " |      If `name` and `index` are both provided, `index` will take precedence.\n",
            " |      Indices are based on order of horizontal graph traversal (bottom-up).\n",
            " |      \n",
            " |      Arguments:\n",
            " |          name: String, name of layer.\n",
            " |          index: Integer, index of layer.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A layer instance.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: In case of invalid layer name or index.\n",
            " |  \n",
            " |  reset_states(self)\n",
            " |  \n",
            " |  save(self, filepath, overwrite=True, include_optimizer=True, save_format=None, signatures=None, options=None)\n",
            " |      Saves the model to Tensorflow SavedModel or a single HDF5 file.\n",
            " |      \n",
            " |      The savefile includes:\n",
            " |          - The model architecture, allowing to re-instantiate the model.\n",
            " |          - The model weights.\n",
            " |          - The state of the optimizer, allowing to resume training\n",
            " |              exactly where you left off.\n",
            " |      \n",
            " |      This allows you to save the entirety of the state of a model\n",
            " |      in a single file.\n",
            " |      \n",
            " |      Saved models can be reinstantiated via `keras.models.load_model`.\n",
            " |      The model returned by `load_model`\n",
            " |      is a compiled model ready to be used (unless the saved model\n",
            " |      was never compiled in the first place).\n",
            " |      \n",
            " |      Arguments:\n",
            " |          filepath: String, path to SavedModel or H5 file to save the model.\n",
            " |          overwrite: Whether to silently overwrite any existing file at the\n",
            " |              target location, or provide the user with a manual prompt.\n",
            " |          include_optimizer: If True, save optimizer's state together.\n",
            " |          save_format: Either 'tf' or 'h5', indicating whether to save the model\n",
            " |            to Tensorflow SavedModel or HDF5. The default is currently 'h5', but\n",
            " |            will switch to 'tf' in TensorFlow 2.0. The 'tf' option is currently\n",
            " |            disabled (use `tf.keras.experimental.export_saved_model` instead).\n",
            " |        signatures: Signatures to save with the SavedModel. Applicable to the 'tf'\n",
            " |          format only. Please see the `signatures` argument in\n",
            " |          `tf.saved_model.save` for details.\n",
            " |        options: Optional `tf.saved_model.SaveOptions` object that specifies\n",
            " |          options for saving to SavedModel.\n",
            " |      \n",
            " |      Example:\n",
            " |      \n",
            " |      ```python\n",
            " |      from keras.models import load_model\n",
            " |      \n",
            " |      model.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'\n",
            " |      del model  # deletes the existing model\n",
            " |      \n",
            " |      # returns a compiled model\n",
            " |      # identical to the previous one\n",
            " |      model = load_model('my_model.h5')\n",
            " |      ```\n",
            " |  \n",
            " |  save_weights(self, filepath, overwrite=True, save_format=None)\n",
            " |      Saves all layer weights.\n",
            " |      \n",
            " |      Either saves in HDF5 or in TensorFlow format based on the `save_format`\n",
            " |      argument.\n",
            " |      \n",
            " |      When saving in HDF5 format, the weight file has:\n",
            " |        - `layer_names` (attribute), a list of strings\n",
            " |            (ordered names of model layers).\n",
            " |        - For every layer, a `group` named `layer.name`\n",
            " |            - For every such layer group, a group attribute `weight_names`,\n",
            " |                a list of strings\n",
            " |                (ordered names of weights tensor of the layer).\n",
            " |            - For every weight in the layer, a dataset\n",
            " |                storing the weight value, named after the weight tensor.\n",
            " |      \n",
            " |      When saving in TensorFlow format, all objects referenced by the network are\n",
            " |      saved in the same format as `tf.train.Checkpoint`, including any `Layer`\n",
            " |      instances or `Optimizer` instances assigned to object attributes. For\n",
            " |      networks constructed from inputs and outputs using `tf.keras.Model(inputs,\n",
            " |      outputs)`, `Layer` instances used by the network are tracked/saved\n",
            " |      automatically. For user-defined classes which inherit from `tf.keras.Model`,\n",
            " |      `Layer` instances must be assigned to object attributes, typically in the\n",
            " |      constructor. See the documentation of `tf.train.Checkpoint` and\n",
            " |      `tf.keras.Model` for details.\n",
            " |      \n",
            " |      While the formats are the same, do not mix `save_weights` and\n",
            " |      `tf.train.Checkpoint`. Checkpoints saved by `Model.save_weights` should be\n",
            " |      loaded using `Model.load_weights`. Checkpoints saved using\n",
            " |      `tf.train.Checkpoint.save` should be restored using the corresponding\n",
            " |      `tf.train.Checkpoint.restore`. Prefer `tf.train.Checkpoint` over\n",
            " |      `save_weights` for training checkpoints.\n",
            " |      \n",
            " |      The TensorFlow format matches objects and variables by starting at a root\n",
            " |      object, `self` for `save_weights`, and greedily matching attribute\n",
            " |      names. For `Model.save` this is the `Model`, and for `Checkpoint.save` this\n",
            " |      is the `Checkpoint` even if the `Checkpoint` has a model attached. This\n",
            " |      means saving a `tf.keras.Model` using `save_weights` and loading into a\n",
            " |      `tf.train.Checkpoint` with a `Model` attached (or vice versa) will not match\n",
            " |      the `Model`'s variables. See the [guide to training\n",
            " |      checkpoints](https://www.tensorflow.org/alpha/guide/checkpoints) for details\n",
            " |      on the TensorFlow format.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          filepath: String, path to the file to save the weights to. When saving\n",
            " |              in TensorFlow format, this is the prefix used for checkpoint files\n",
            " |              (multiple files are generated). Note that the '.h5' suffix causes\n",
            " |              weights to be saved in HDF5 format.\n",
            " |          overwrite: Whether to silently overwrite any existing file at the\n",
            " |              target location, or provide the user with a manual prompt.\n",
            " |          save_format: Either 'tf' or 'h5'. A `filepath` ending in '.h5' or\n",
            " |              '.keras' will default to HDF5 if `save_format` is `None`. Otherwise\n",
            " |              `None` defaults to 'tf'.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ImportError: If h5py is not available when attempting to save in HDF5\n",
            " |              format.\n",
            " |          ValueError: For invalid/unknown format arguments.\n",
            " |  \n",
            " |  summary(self, line_length=None, positions=None, print_fn=None)\n",
            " |      Prints a string summary of the network.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          line_length: Total length of printed lines\n",
            " |              (e.g. set this to adapt the display to different\n",
            " |              terminal window sizes).\n",
            " |          positions: Relative or absolute positions of log elements\n",
            " |              in each line. If not provided,\n",
            " |              defaults to `[.33, .55, .67, 1.]`.\n",
            " |          print_fn: Print function to use. Defaults to `print`.\n",
            " |              It will be called on each line of the summary.\n",
            " |              You can set it to a custom function\n",
            " |              in order to capture the string summary.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: if `summary()` is called before the model is built.\n",
            " |  \n",
            " |  to_json(self, **kwargs)\n",
            " |      Returns a JSON string containing the network configuration.\n",
            " |      \n",
            " |      To load a network from a JSON save file, use\n",
            " |      `keras.models.model_from_json(json_string, custom_objects={})`.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          **kwargs: Additional keyword arguments\n",
            " |              to be passed to `json.dumps()`.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A JSON string.\n",
            " |  \n",
            " |  to_yaml(self, **kwargs)\n",
            " |      Returns a yaml string containing the network configuration.\n",
            " |      \n",
            " |      To load a network from a yaml save file, use\n",
            " |      `keras.models.model_from_yaml(yaml_string, custom_objects={})`.\n",
            " |      \n",
            " |      `custom_objects` should be a dictionary mapping\n",
            " |      the names of custom losses / layers / etc to the corresponding\n",
            " |      functions / classes.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          **kwargs: Additional keyword arguments\n",
            " |              to be passed to `yaml.dump()`.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A YAML string.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ImportError: if yaml module is not found.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data descriptors inherited from tensorflow.python.keras.engine.network.Network:\n",
            " |  \n",
            " |  non_trainable_weights\n",
            " |  \n",
            " |  state_updates\n",
            " |      Returns the `updates` from all layers that are stateful.\n",
            " |      \n",
            " |      This is useful for separating training updates and\n",
            " |      state updates, e.g. when we need to update a layer's internal state\n",
            " |      during prediction.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A list of update ops.\n",
            " |  \n",
            " |  stateful\n",
            " |  \n",
            " |  trainable_weights\n",
            " |  \n",
            " |  weights\n",
            " |      Returns the list of all layer variables/weights.\n",
            " |      \n",
            " |      Returns:\n",
            " |        A list of variables.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Methods inherited from tensorflow.python.keras.engine.base_layer.Layer:\n",
            " |  \n",
            " |  __call__(self, inputs, *args, **kwargs)\n",
            " |      Wraps `call`, applying pre- and post-processing steps.\n",
            " |      \n",
            " |      Arguments:\n",
            " |        inputs: input tensor(s).\n",
            " |        *args: additional positional arguments to be passed to `self.call`.\n",
            " |        **kwargs: additional keyword arguments to be passed to `self.call`.\n",
            " |      \n",
            " |      Returns:\n",
            " |        Output tensor(s).\n",
            " |      \n",
            " |      Note:\n",
            " |        - The following optional keyword arguments are reserved for specific uses:\n",
            " |          * `training`: Boolean scalar tensor of Python boolean indicating\n",
            " |            whether the `call` is meant for training or inference.\n",
            " |          * `mask`: Boolean input mask.\n",
            " |        - If the layer's `call` method takes a `mask` argument (as some Keras\n",
            " |          layers do), its default value will be set to the mask generated\n",
            " |          for `inputs` by the previous layer (if `input` did come from\n",
            " |          a layer that generated a corresponding mask, i.e. if it came from\n",
            " |          a Keras layer with masking support.\n",
            " |      \n",
            " |      Raises:\n",
            " |        ValueError: if the layer's `call` method returns None (an invalid value).\n",
            " |  \n",
            " |  __delattr__(self, name)\n",
            " |      Implement delattr(self, name).\n",
            " |  \n",
            " |  add_loss(self, losses, inputs=None)\n",
            " |      Add loss tensor(s), potentially dependent on layer inputs.\n",
            " |      \n",
            " |      Some losses (for instance, activity regularization losses) may be dependent\n",
            " |      on the inputs passed when calling a layer. Hence, when reusing the same\n",
            " |      layer on different inputs `a` and `b`, some entries in `layer.losses` may\n",
            " |      be dependent on `a` and some on `b`. This method automatically keeps track\n",
            " |      of dependencies.\n",
            " |      \n",
            " |      This method can be used inside a subclassed layer or model's `call`\n",
            " |      function, in which case `losses` should be a Tensor or list of Tensors.\n",
            " |      \n",
            " |      Example:\n",
            " |      \n",
            " |      ```python\n",
            " |      class MyLayer(tf.keras.layers.Layer):\n",
            " |        def call(inputs, self):\n",
            " |          self.add_loss(tf.abs(tf.reduce_mean(inputs)), inputs=True)\n",
            " |          return inputs\n",
            " |      ```\n",
            " |      \n",
            " |      This method can also be called directly on a Functional Model during\n",
            " |      construction. In this case, any loss Tensors passed to this Model must\n",
            " |      be symbolic and be able to be traced back to the model's `Input`s. These\n",
            " |      losses become part of the model's topology and are tracked in `get_config`.\n",
            " |      \n",
            " |      Example:\n",
            " |      \n",
            " |      ```python\n",
            " |      inputs = tf.keras.Input(shape=(10,))\n",
            " |      x = tf.keras.layers.Dense(10)(inputs)\n",
            " |      outputs = tf.keras.layers.Dense(1)(x)\n",
            " |      model = tf.keras.Model(inputs, outputs)\n",
            " |      # Actvity regularization.\n",
            " |      model.add_loss(tf.abs(tf.reduce_mean(x)))\n",
            " |      ```\n",
            " |      \n",
            " |      If this is not the case for your loss (if, for example, your loss references\n",
            " |      a `Variable` of one of the model's layers), you can wrap your loss in a\n",
            " |      zero-argument lambda. These losses are not tracked as part of the model's\n",
            " |      topology since they can't be serialized.\n",
            " |      \n",
            " |      Example:\n",
            " |      \n",
            " |      ```python\n",
            " |      inputs = tf.keras.Input(shape=(10,))\n",
            " |      x = tf.keras.layers.Dense(10)(inputs)\n",
            " |      outputs = tf.keras.layers.Dense(1)(x)\n",
            " |      model = tf.keras.Model(inputs, outputs)\n",
            " |      # Weight regularization.\n",
            " |      model.add_loss(lambda: tf.reduce_mean(x.kernel))\n",
            " |      ```\n",
            " |      \n",
            " |      The `get_losses_for` method allows to retrieve the losses relevant to a\n",
            " |      specific set of inputs.\n",
            " |      \n",
            " |      Arguments:\n",
            " |        losses: Loss tensor, or list/tuple of tensors. Rather than tensors, losses\n",
            " |          may also be zero-argument callables which create a loss tensor.\n",
            " |        inputs: Ignored when executing eagerly. If anything other than None is\n",
            " |          passed, it signals the losses are conditional on some of the layer's\n",
            " |          inputs, and thus they should only be run where these inputs are\n",
            " |          available. This is the case for activity regularization losses, for\n",
            " |          instance. If `None` is passed, the losses are assumed\n",
            " |          to be unconditional, and will apply across all dataflows of the layer\n",
            " |          (e.g. weight regularization losses).\n",
            " |  \n",
            " |  add_metric(self, value, aggregation=None, name=None)\n",
            " |      Adds metric tensor to the layer.\n",
            " |      \n",
            " |      Args:\n",
            " |        value: Metric tensor.\n",
            " |        aggregation: Sample-wise metric reduction function. If `aggregation=None`,\n",
            " |          it indicates that the metric tensor provided has been aggregated\n",
            " |          already. eg, `bin_acc = BinaryAccuracy(name='acc')` followed by\n",
            " |          `model.add_metric(bin_acc(y_true, y_pred))`. If aggregation='mean', the\n",
            " |          given metric tensor will be sample-wise reduced using `mean` function.\n",
            " |          eg, `model.add_metric(tf.reduce_sum(outputs), name='output_mean',\n",
            " |          aggregation='mean')`.\n",
            " |        name: String metric name.\n",
            " |      \n",
            " |      Raises:\n",
            " |        ValueError: If `aggregation` is anything other than None or `mean`.\n",
            " |  \n",
            " |  add_update(self, updates, inputs=None)\n",
            " |      Add update op(s), potentially dependent on layer inputs. (deprecated arguments)\n",
            " |      \n",
            " |      Warning: SOME ARGUMENTS ARE DEPRECATED: `(inputs)`. They will be removed in a future version.\n",
            " |      Instructions for updating:\n",
            " |      `inputs` is now automatically inferred\n",
            " |      \n",
            " |      Weight updates (for instance, the updates of the moving mean and variance\n",
            " |      in a BatchNormalization layer) may be dependent on the inputs passed\n",
            " |      when calling a layer. Hence, when reusing the same layer on\n",
            " |      different inputs `a` and `b`, some entries in `layer.updates` may be\n",
            " |      dependent on `a` and some on `b`. This method automatically keeps track\n",
            " |      of dependencies.\n",
            " |      \n",
            " |      The `get_updates_for` method allows to retrieve the updates relevant to a\n",
            " |      specific set of inputs.\n",
            " |      \n",
            " |      This call is ignored when eager execution is enabled (in that case, variable\n",
            " |      updates are run on the fly and thus do not need to be tracked for later\n",
            " |      execution).\n",
            " |      \n",
            " |      Arguments:\n",
            " |        updates: Update op, or list/tuple of update ops, or zero-arg callable\n",
            " |          that returns an update op. A zero-arg callable should be passed in\n",
            " |          order to disable running the updates by setting `trainable=False`\n",
            " |          on this Layer, when executing in Eager mode.\n",
            " |        inputs: Deprecated, will be automatically inferred.\n",
            " |  \n",
            " |  add_variable(self, *args, **kwargs)\n",
            " |      Deprecated, do NOT use! Alias for `add_weight`. (deprecated)\n",
            " |      \n",
            " |      Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\n",
            " |      Instructions for updating:\n",
            " |      Please use `layer.add_weight` method instead.\n",
            " |  \n",
            " |  add_weight(self, name=None, shape=None, dtype=None, initializer=None, regularizer=None, trainable=None, constraint=None, partitioner=None, use_resource=None, synchronization=<VariableSynchronization.AUTO: 0>, aggregation=<VariableAggregation.NONE: 0>, **kwargs)\n",
            " |      Adds a new variable to the layer.\n",
            " |      \n",
            " |      Arguments:\n",
            " |        name: Variable name.\n",
            " |        shape: Variable shape. Defaults to scalar if unspecified.\n",
            " |        dtype: The type of the variable. Defaults to `self.dtype` or `float32`.\n",
            " |        initializer: Initializer instance (callable).\n",
            " |        regularizer: Regularizer instance (callable).\n",
            " |        trainable: Boolean, whether the variable should be part of the layer's\n",
            " |          \"trainable_variables\" (e.g. variables, biases)\n",
            " |          or \"non_trainable_variables\" (e.g. BatchNorm mean and variance).\n",
            " |          Note that `trainable` cannot be `True` if `synchronization`\n",
            " |          is set to `ON_READ`.\n",
            " |        constraint: Constraint instance (callable).\n",
            " |        partitioner: Partitioner to be passed to the `Trackable` API.\n",
            " |        use_resource: Whether to use `ResourceVariable`.\n",
            " |        synchronization: Indicates when a distributed a variable will be\n",
            " |          aggregated. Accepted values are constants defined in the class\n",
            " |          `tf.VariableSynchronization`. By default the synchronization is set to\n",
            " |          `AUTO` and the current `DistributionStrategy` chooses\n",
            " |          when to synchronize. If `synchronization` is set to `ON_READ`,\n",
            " |          `trainable` must not be set to `True`.\n",
            " |        aggregation: Indicates how a distributed variable will be aggregated.\n",
            " |          Accepted values are constants defined in the class\n",
            " |          `tf.VariableAggregation`.\n",
            " |        **kwargs: Additional keyword arguments. Accepted values are `getter` and\n",
            " |          `collections`.\n",
            " |      \n",
            " |      Returns:\n",
            " |        The created variable. Usually either a `Variable` or `ResourceVariable`\n",
            " |        instance. If `partitioner` is not `None`, a `PartitionedVariable`\n",
            " |        instance is returned.\n",
            " |      \n",
            " |      Raises:\n",
            " |        RuntimeError: If called with partitioned variable regularization and\n",
            " |          eager execution is enabled.\n",
            " |        ValueError: When giving unsupported dtype and no initializer or when\n",
            " |          trainable has been set to True with synchronization set as `ON_READ`.\n",
            " |  \n",
            " |  apply(self, inputs, *args, **kwargs)\n",
            " |      Deprecated, do NOT use! (deprecated)\n",
            " |      \n",
            " |      Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\n",
            " |      Instructions for updating:\n",
            " |      Please use `layer.__call__` method instead.\n",
            " |      \n",
            " |      This is an alias of `self.__call__`.\n",
            " |      \n",
            " |      Arguments:\n",
            " |        inputs: Input tensor(s).\n",
            " |        *args: additional positional arguments to be passed to `self.call`.\n",
            " |        **kwargs: additional keyword arguments to be passed to `self.call`.\n",
            " |      \n",
            " |      Returns:\n",
            " |        Output tensor(s).\n",
            " |  \n",
            " |  compute_output_signature(self, input_signature)\n",
            " |      Compute the output tensor signature of the layer based on the inputs.\n",
            " |      \n",
            " |      Unlike a TensorShape object, a TensorSpec object contains both shape\n",
            " |      and dtype information for a tensor. This method allows layers to provide\n",
            " |      output dtype information if it is different from the input dtype.\n",
            " |      For any layer that doesn't implement this function,\n",
            " |      the framework will fall back to use `compute_output_shape`, and will\n",
            " |      assume that the output dtype matches the input dtype.\n",
            " |      \n",
            " |      Args:\n",
            " |        input_signature: Single TensorSpec or nested structure of TensorSpec\n",
            " |          objects, describing a candidate input for the layer.\n",
            " |      \n",
            " |      Returns:\n",
            " |        Single TensorSpec or nested structure of TensorSpec objects, describing\n",
            " |          how the layer would transform the provided input.\n",
            " |      \n",
            " |      Raises:\n",
            " |        TypeError: If input_signature contains a non-TensorSpec object.\n",
            " |  \n",
            " |  count_params(self)\n",
            " |      Count the total number of scalars composing the weights.\n",
            " |      \n",
            " |      Returns:\n",
            " |          An integer count.\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: if the layer isn't yet built\n",
            " |            (in which case its weights aren't yet defined).\n",
            " |  \n",
            " |  get_input_at(self, node_index)\n",
            " |      Retrieves the input tensor(s) of a layer at a given node.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          node_index: Integer, index of the node\n",
            " |              from which to retrieve the attribute.\n",
            " |              E.g. `node_index=0` will correspond to the\n",
            " |              first time the layer was called.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A tensor (or list of tensors if the layer has multiple inputs).\n",
            " |      \n",
            " |      Raises:\n",
            " |        RuntimeError: If called in Eager mode.\n",
            " |  \n",
            " |  get_input_mask_at(self, node_index)\n",
            " |      Retrieves the input mask tensor(s) of a layer at a given node.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          node_index: Integer, index of the node\n",
            " |              from which to retrieve the attribute.\n",
            " |              E.g. `node_index=0` will correspond to the\n",
            " |              first time the layer was called.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A mask tensor\n",
            " |          (or list of tensors if the layer has multiple inputs).\n",
            " |  \n",
            " |  get_input_shape_at(self, node_index)\n",
            " |      Retrieves the input shape(s) of a layer at a given node.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          node_index: Integer, index of the node\n",
            " |              from which to retrieve the attribute.\n",
            " |              E.g. `node_index=0` will correspond to the\n",
            " |              first time the layer was called.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A shape tuple\n",
            " |          (or list of shape tuples if the layer has multiple inputs).\n",
            " |      \n",
            " |      Raises:\n",
            " |        RuntimeError: If called in Eager mode.\n",
            " |  \n",
            " |  get_losses_for(self, inputs)\n",
            " |      Retrieves losses relevant to a specific set of inputs.\n",
            " |      \n",
            " |      Arguments:\n",
            " |        inputs: Input tensor or list/tuple of input tensors.\n",
            " |      \n",
            " |      Returns:\n",
            " |        List of loss tensors of the layer that depend on `inputs`.\n",
            " |  \n",
            " |  get_output_at(self, node_index)\n",
            " |      Retrieves the output tensor(s) of a layer at a given node.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          node_index: Integer, index of the node\n",
            " |              from which to retrieve the attribute.\n",
            " |              E.g. `node_index=0` will correspond to the\n",
            " |              first time the layer was called.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A tensor (or list of tensors if the layer has multiple outputs).\n",
            " |      \n",
            " |      Raises:\n",
            " |        RuntimeError: If called in Eager mode.\n",
            " |  \n",
            " |  get_output_mask_at(self, node_index)\n",
            " |      Retrieves the output mask tensor(s) of a layer at a given node.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          node_index: Integer, index of the node\n",
            " |              from which to retrieve the attribute.\n",
            " |              E.g. `node_index=0` will correspond to the\n",
            " |              first time the layer was called.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A mask tensor\n",
            " |          (or list of tensors if the layer has multiple outputs).\n",
            " |  \n",
            " |  get_output_shape_at(self, node_index)\n",
            " |      Retrieves the output shape(s) of a layer at a given node.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          node_index: Integer, index of the node\n",
            " |              from which to retrieve the attribute.\n",
            " |              E.g. `node_index=0` will correspond to the\n",
            " |              first time the layer was called.\n",
            " |      \n",
            " |      Returns:\n",
            " |          A shape tuple\n",
            " |          (or list of shape tuples if the layer has multiple outputs).\n",
            " |      \n",
            " |      Raises:\n",
            " |        RuntimeError: If called in Eager mode.\n",
            " |  \n",
            " |  get_updates_for(self, inputs)\n",
            " |      Retrieves updates relevant to a specific set of inputs.\n",
            " |      \n",
            " |      Arguments:\n",
            " |        inputs: Input tensor or list/tuple of input tensors.\n",
            " |      \n",
            " |      Returns:\n",
            " |        List of update ops of the layer that depend on `inputs`.\n",
            " |  \n",
            " |  set_weights(self, weights)\n",
            " |      Sets the weights of the layer, from Numpy arrays.\n",
            " |      \n",
            " |      Arguments:\n",
            " |          weights: a list of Numpy arrays. The number\n",
            " |              of arrays and their shape must match\n",
            " |              number of the dimensions of the weights\n",
            " |              of the layer (i.e. it should match the\n",
            " |              output of `get_weights`).\n",
            " |      \n",
            " |      Raises:\n",
            " |          ValueError: If the provided weights list does not match the\n",
            " |              layer's specifications.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data descriptors inherited from tensorflow.python.keras.engine.base_layer.Layer:\n",
            " |  \n",
            " |  activity_regularizer\n",
            " |      Optional regularizer function for the output of this layer.\n",
            " |  \n",
            " |  dtype\n",
            " |  \n",
            " |  inbound_nodes\n",
            " |      Deprecated, do NOT use! Only for compatibility with external Keras.\n",
            " |  \n",
            " |  input\n",
            " |      Retrieves the input tensor(s) of a layer.\n",
            " |      \n",
            " |      Only applicable if the layer has exactly one input,\n",
            " |      i.e. if it is connected to one incoming layer.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Input tensor or list of input tensors.\n",
            " |      \n",
            " |      Raises:\n",
            " |        RuntimeError: If called in Eager mode.\n",
            " |        AttributeError: If no inbound nodes are found.\n",
            " |  \n",
            " |  input_mask\n",
            " |      Retrieves the input mask tensor(s) of a layer.\n",
            " |      \n",
            " |      Only applicable if the layer has exactly one inbound node,\n",
            " |      i.e. if it is connected to one incoming layer.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Input mask tensor (potentially None) or list of input\n",
            " |          mask tensors.\n",
            " |      \n",
            " |      Raises:\n",
            " |          AttributeError: if the layer is connected to\n",
            " |          more than one incoming layers.\n",
            " |  \n",
            " |  input_shape\n",
            " |      Retrieves the input shape(s) of a layer.\n",
            " |      \n",
            " |      Only applicable if the layer has exactly one input,\n",
            " |      i.e. if it is connected to one incoming layer, or if all inputs\n",
            " |      have the same shape.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Input shape, as an integer shape tuple\n",
            " |          (or list of shape tuples, one tuple per input tensor).\n",
            " |      \n",
            " |      Raises:\n",
            " |          AttributeError: if the layer has no defined input_shape.\n",
            " |          RuntimeError: if called in Eager mode.\n",
            " |  \n",
            " |  losses\n",
            " |      Losses which are associated with this `Layer`.\n",
            " |      \n",
            " |      Variable regularization tensors are created when this property is accessed,\n",
            " |      so it is eager safe: accessing `losses` under a `tf.GradientTape` will\n",
            " |      propagate gradients back to the corresponding variables.\n",
            " |      \n",
            " |      Returns:\n",
            " |        A list of tensors.\n",
            " |  \n",
            " |  name\n",
            " |      Returns the name of this module as passed or determined in the ctor.\n",
            " |      \n",
            " |      NOTE: This is not the same as the `self.name_scope.name` which includes\n",
            " |      parent module names.\n",
            " |  \n",
            " |  non_trainable_variables\n",
            " |  \n",
            " |  outbound_nodes\n",
            " |      Deprecated, do NOT use! Only for compatibility with external Keras.\n",
            " |  \n",
            " |  output\n",
            " |      Retrieves the output tensor(s) of a layer.\n",
            " |      \n",
            " |      Only applicable if the layer has exactly one output,\n",
            " |      i.e. if it is connected to one incoming layer.\n",
            " |      \n",
            " |      Returns:\n",
            " |        Output tensor or list of output tensors.\n",
            " |      \n",
            " |      Raises:\n",
            " |        AttributeError: if the layer is connected to more than one incoming\n",
            " |          layers.\n",
            " |        RuntimeError: if called in Eager mode.\n",
            " |  \n",
            " |  output_mask\n",
            " |      Retrieves the output mask tensor(s) of a layer.\n",
            " |      \n",
            " |      Only applicable if the layer has exactly one inbound node,\n",
            " |      i.e. if it is connected to one incoming layer.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Output mask tensor (potentially None) or list of output\n",
            " |          mask tensors.\n",
            " |      \n",
            " |      Raises:\n",
            " |          AttributeError: if the layer is connected to\n",
            " |          more than one incoming layers.\n",
            " |  \n",
            " |  output_shape\n",
            " |      Retrieves the output shape(s) of a layer.\n",
            " |      \n",
            " |      Only applicable if the layer has one output,\n",
            " |      or if all outputs have the same shape.\n",
            " |      \n",
            " |      Returns:\n",
            " |          Output shape, as an integer shape tuple\n",
            " |          (or list of shape tuples, one tuple per output tensor).\n",
            " |      \n",
            " |      Raises:\n",
            " |          AttributeError: if the layer has no defined output shape.\n",
            " |          RuntimeError: if called in Eager mode.\n",
            " |  \n",
            " |  trainable\n",
            " |  \n",
            " |  trainable_variables\n",
            " |      Sequence of variables owned by this module and it's submodules.\n",
            " |      \n",
            " |      Note: this method uses reflection to find variables on the current instance\n",
            " |      and submodules. For performance reasons you may wish to cache the result\n",
            " |      of calling this method if you don't expect the return value to change.\n",
            " |      \n",
            " |      Returns:\n",
            " |        A sequence of variables for the current module (sorted by attribute\n",
            " |        name) followed by variables from all submodules recursively (breadth\n",
            " |        first).\n",
            " |  \n",
            " |  updates\n",
            " |  \n",
            " |  variables\n",
            " |      Returns the list of all layer variables/weights.\n",
            " |      \n",
            " |      Alias of `self.weights`.\n",
            " |      \n",
            " |      Returns:\n",
            " |        A list of variables.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Class methods inherited from tensorflow.python.module.module.Module:\n",
            " |  \n",
            " |  with_name_scope(method) from builtins.type\n",
            " |      Decorator to automatically enter the module name scope.\n",
            " |      \n",
            " |      ```\n",
            " |      class MyModule(tf.Module):\n",
            " |        @tf.Module.with_name_scope\n",
            " |        def __call__(self, x):\n",
            " |          if not hasattr(self, 'w'):\n",
            " |            self.w = tf.Variable(tf.random.normal([x.shape[1], 64]))\n",
            " |          return tf.matmul(x, self.w)\n",
            " |      ```\n",
            " |      \n",
            " |      Using the above module would produce `tf.Variable`s and `tf.Tensor`s whose\n",
            " |      names included the module name:\n",
            " |      \n",
            " |      ```\n",
            " |      mod = MyModule()\n",
            " |      mod(tf.ones([8, 32]))\n",
            " |      # ==> <tf.Tensor: ...>\n",
            " |      mod.w\n",
            " |      # ==> <tf.Variable ...'my_module/w:0'>\n",
            " |      ```\n",
            " |      \n",
            " |      Args:\n",
            " |        method: The method to wrap.\n",
            " |      \n",
            " |      Returns:\n",
            " |        The original method wrapped such that it enters the module's name scope.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data descriptors inherited from tensorflow.python.module.module.Module:\n",
            " |  \n",
            " |  name_scope\n",
            " |      Returns a `tf.name_scope` instance for this class.\n",
            " |  \n",
            " |  submodules\n",
            " |      Sequence of all sub-modules.\n",
            " |      \n",
            " |      Submodules are modules which are properties of this module, or found as\n",
            " |      properties of modules which are properties of this module (and so on).\n",
            " |      \n",
            " |      ```\n",
            " |      a = tf.Module()\n",
            " |      b = tf.Module()\n",
            " |      c = tf.Module()\n",
            " |      a.b = b\n",
            " |      b.c = c\n",
            " |      assert list(a.submodules) == [b, c]\n",
            " |      assert list(b.submodules) == [c]\n",
            " |      assert list(c.submodules) == []\n",
            " |      ```\n",
            " |      \n",
            " |      Returns:\n",
            " |        A sequence of all submodules.\n",
            " |  \n",
            " |  ----------------------------------------------------------------------\n",
            " |  Data descriptors inherited from tensorflow.python.training.tracking.base.Trackable:\n",
            " |  \n",
            " |  __dict__\n",
            " |      dictionary for instance variables (if defined)\n",
            " |  \n",
            " |  __weakref__\n",
            " |      list of weak references to the object (if defined)\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UmGhj2XCbTGg"
      },
      "source": [
        "## Creating a Model\n",
        "\n",
        "There are two ways to create models through the TF 2 Keras API, either pass in a list of layers all at once, or add them one by one.\n",
        "\n",
        "Let's show both methods (its up to you to choose which method you prefer)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LvMBDOKCbTGi"
      },
      "source": [
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Activation"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SkbCLDPfbTGl"
      },
      "source": [
        "### Model - as a list of layers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "viiNfSJCbTGm"
      },
      "source": [
        "model = Sequential([\n",
        "    Dense(units=2),\n",
        "    Dense(units=2),\n",
        "    Dense(units=2)\n",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7tYycVMEbTGq"
      },
      "source": [
        "### Model - adding in layers one by one"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RYfiJNX5bTGr"
      },
      "source": [
        "model = Sequential()\n",
        "\n",
        "model.add(Dense(2))\n",
        "model.add(Dense(2))\n",
        "model.add(Dense(2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pzfG2gKCbTGw"
      },
      "source": [
        "Let's go ahead and build a simple model and then compile it by defining our solver"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h_F3NNgrbTGx"
      },
      "source": [
        "model = Sequential()\n",
        "\n",
        "model.add(Dense(4,activation='relu'))\n",
        "model.add(Dense(4,activation='relu'))\n",
        "model.add(Dense(4,activation='relu'))\n",
        "\n",
        "# Final output node for prediction\n",
        "model.add(Dense(1))\n",
        "\n",
        "model.compile(optimizer='rmsprop',loss='mse')# loss function is MSE. because y is continous."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MojDfBsPbTG0"
      },
      "source": [
        "### Choosing an optimizer and loss\n",
        "\n",
        "Keep in mind what kind of problem you are trying to solve:\n",
        "\n",
        "    # For a multi-class classification problem\n",
        "    model.compile(optimizer='rmsprop',\n",
        "                  loss='categorical_crossentropy',\n",
        "                  metrics=['accuracy'])\n",
        "\n",
        "    # For a binary classification problem\n",
        "    model.compile(optimizer='rmsprop',\n",
        "                  loss='binary_crossentropy',\n",
        "                  metrics=['accuracy'])\n",
        "\n",
        "    # For a mean squared error regression problem\n",
        "    model.compile(optimizer='rmsprop',\n",
        "                  loss='mse')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MSKk8gBJbTG1"
      },
      "source": [
        "# Training\n",
        "\n",
        "Below are some common definitions that are necessary to know and understand to correctly utilize Keras:\n",
        "\n",
        "* Sample: one element of a dataset.\n",
        "    * Example: one image is a sample in a convolutional network\n",
        "    * Example: one audio file is a sample for a speech recognition model\n",
        "* Batch: a set of N samples. The samples in a batch are processed independently, in parallel. If training, a batch results in only one update to the model.A batch generally approximates the distribution of the input data better than a single input. The larger the batch, the better the approximation; however, it is also true that the batch will take longer to process and will still result in only one update. For inference (evaluate/predict), it is recommended to pick a batch size that is as large as you can afford without going out of memory (since larger batches will usually result in faster evaluation/prediction).\n",
        "* Epoch: an arbitrary cutoff, generally defined as \"one pass over the entire dataset\", used to separate training into distinct phases, which is useful for logging and periodic evaluation.\n",
        "* When using validation_data or validation_split with the fit method of Keras models, evaluation will be run at the end of every epoch.\n",
        "* Within Keras, there is the ability to add callbacks specifically designed to be run at the end of an epoch. Examples of these are learning rate changes and model checkpointing (saving)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06b0tQ8fbTG2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "81af142c-1b7c-4118-a3d8-de3d87d20706"
      },
      "source": [
        "model.fit(X_train,y_train,epochs=250)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 256619.9062\n",
            "Epoch 2/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 256520.9531\n",
            "Epoch 3/250\n",
            "22/22 [==============================] - 0s 974us/step - loss: 256410.7500\n",
            "Epoch 4/250\n",
            "22/22 [==============================] - 0s 982us/step - loss: 256281.3906\n",
            "Epoch 5/250\n",
            "22/22 [==============================] - 0s 989us/step - loss: 256130.8750\n",
            "Epoch 6/250\n",
            "22/22 [==============================] - 0s 983us/step - loss: 255954.3281\n",
            "Epoch 7/250\n",
            "22/22 [==============================] - 0s 982us/step - loss: 255745.7344\n",
            "Epoch 8/250\n",
            "22/22 [==============================] - 0s 985us/step - loss: 255503.8594\n",
            "Epoch 9/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 255224.3906\n",
            "Epoch 10/250\n",
            "22/22 [==============================] - 0s 985us/step - loss: 254905.5938\n",
            "Epoch 11/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 254542.9688\n",
            "Epoch 12/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 254132.2812\n",
            "Epoch 13/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 253673.7812\n",
            "Epoch 14/250\n",
            "22/22 [==============================] - 0s 2ms/step - loss: 253161.0781\n",
            "Epoch 15/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 252588.9844\n",
            "Epoch 16/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 251952.7031\n",
            "Epoch 17/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 251250.6250\n",
            "Epoch 18/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 250479.6094\n",
            "Epoch 19/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 249635.0625\n",
            "Epoch 20/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 248709.4375\n",
            "Epoch 21/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 247705.8281\n",
            "Epoch 22/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 246604.9219\n",
            "Epoch 23/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 245419.2500\n",
            "Epoch 24/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 244133.8125\n",
            "Epoch 25/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 242745.3438\n",
            "Epoch 26/250\n",
            "22/22 [==============================] - 0s 992us/step - loss: 241252.8906\n",
            "Epoch 27/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 239643.4688\n",
            "Epoch 28/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 237933.0312\n",
            "Epoch 29/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 236092.0156\n",
            "Epoch 30/250\n",
            "22/22 [==============================] - 0s 961us/step - loss: 234141.1719\n",
            "Epoch 31/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 232063.6562\n",
            "Epoch 32/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 229830.0625\n",
            "Epoch 33/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 227473.5781\n",
            "Epoch 34/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 224983.1094\n",
            "Epoch 35/250\n",
            "22/22 [==============================] - 0s 2ms/step - loss: 222339.6875\n",
            "Epoch 36/250\n",
            "22/22 [==============================] - 0s 2ms/step - loss: 219554.9219\n",
            "Epoch 37/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 216608.1094\n",
            "Epoch 38/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 213520.4062\n",
            "Epoch 39/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 210257.1719\n",
            "Epoch 40/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 206862.0312\n",
            "Epoch 41/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 203304.3125\n",
            "Epoch 42/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 199564.1562\n",
            "Epoch 43/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 195668.6562\n",
            "Epoch 44/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 191587.4844\n",
            "Epoch 45/250\n",
            "22/22 [==============================] - 0s 978us/step - loss: 187376.0625\n",
            "Epoch 46/250\n",
            "22/22 [==============================] - 0s 916us/step - loss: 182990.4062\n",
            "Epoch 47/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 178433.7031\n",
            "Epoch 48/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 173724.0156\n",
            "Epoch 49/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 168844.7031\n",
            "Epoch 50/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 163807.7188\n",
            "Epoch 51/250\n",
            "22/22 [==============================] - 0s 917us/step - loss: 158637.5156\n",
            "Epoch 52/250\n",
            "22/22 [==============================] - 0s 945us/step - loss: 153281.3906\n",
            "Epoch 53/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 147790.4062\n",
            "Epoch 54/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 142155.8125\n",
            "Epoch 55/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 136423.8281\n",
            "Epoch 56/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 130560.2734\n",
            "Epoch 57/250\n",
            "22/22 [==============================] - 0s 997us/step - loss: 124591.5234\n",
            "Epoch 58/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 118543.4844\n",
            "Epoch 59/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 112372.5156\n",
            "Epoch 60/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 106162.4766\n",
            "Epoch 61/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 99882.2734\n",
            "Epoch 62/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 93539.8984\n",
            "Epoch 63/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 87200.2734\n",
            "Epoch 64/250\n",
            "22/22 [==============================] - 0s 979us/step - loss: 80847.5156\n",
            "Epoch 65/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 74498.5391\n",
            "Epoch 66/250\n",
            "22/22 [==============================] - 0s 998us/step - loss: 68242.7109\n",
            "Epoch 67/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 62056.4570\n",
            "Epoch 68/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 55929.9961\n",
            "Epoch 69/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 50007.2578\n",
            "Epoch 70/250\n",
            "22/22 [==============================] - 0s 936us/step - loss: 44225.1211\n",
            "Epoch 71/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 38634.5703\n",
            "Epoch 72/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 33283.6875\n",
            "Epoch 73/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 28221.0195\n",
            "Epoch 74/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 23431.3301\n",
            "Epoch 75/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 19040.9121\n",
            "Epoch 76/250\n",
            "22/22 [==============================] - 0s 996us/step - loss: 15025.8916\n",
            "Epoch 77/250\n",
            "22/22 [==============================] - 0s 939us/step - loss: 11458.8662\n",
            "Epoch 78/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 8446.8281\n",
            "Epoch 79/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 5946.4897\n",
            "Epoch 80/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 4005.0015\n",
            "Epoch 81/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 2677.5425\n",
            "Epoch 82/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1892.8512\n",
            "Epoch 83/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1604.7452\n",
            "Epoch 84/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1550.1721\n",
            "Epoch 85/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1523.6228\n",
            "Epoch 86/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1493.6512\n",
            "Epoch 87/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1468.1042\n",
            "Epoch 88/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1440.3113\n",
            "Epoch 89/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1409.6760\n",
            "Epoch 90/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1380.0360\n",
            "Epoch 91/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1354.1505\n",
            "Epoch 92/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1326.6169\n",
            "Epoch 93/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1296.9552\n",
            "Epoch 94/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1270.7170\n",
            "Epoch 95/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1243.0935\n",
            "Epoch 96/250\n",
            "22/22 [==============================] - 0s 963us/step - loss: 1216.6991\n",
            "Epoch 97/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1182.5961\n",
            "Epoch 98/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1162.4674\n",
            "Epoch 99/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1137.0161\n",
            "Epoch 100/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1109.2001\n",
            "Epoch 101/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1084.4285\n",
            "Epoch 102/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 1056.0780\n",
            "Epoch 103/250\n",
            "22/22 [==============================] - 0s 993us/step - loss: 1033.2844\n",
            "Epoch 104/250\n",
            "22/22 [==============================] - 0s 959us/step - loss: 1005.1350\n",
            "Epoch 105/250\n",
            "22/22 [==============================] - 0s 983us/step - loss: 986.5837\n",
            "Epoch 106/250\n",
            "22/22 [==============================] - 0s 969us/step - loss: 962.7946\n",
            "Epoch 107/250\n",
            "22/22 [==============================] - 0s 985us/step - loss: 939.3819\n",
            "Epoch 108/250\n",
            "22/22 [==============================] - 0s 941us/step - loss: 913.5844\n",
            "Epoch 109/250\n",
            "22/22 [==============================] - 0s 918us/step - loss: 888.2307\n",
            "Epoch 110/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 865.3690\n",
            "Epoch 111/250\n",
            "22/22 [==============================] - 0s 924us/step - loss: 845.6357\n",
            "Epoch 112/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 820.3624\n",
            "Epoch 113/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 798.3108\n",
            "Epoch 114/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 776.1204\n",
            "Epoch 115/250\n",
            "22/22 [==============================] - 0s 954us/step - loss: 756.5681\n",
            "Epoch 116/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 734.4101\n",
            "Epoch 117/250\n",
            "22/22 [==============================] - 0s 994us/step - loss: 713.7203\n",
            "Epoch 118/250\n",
            "22/22 [==============================] - 0s 955us/step - loss: 693.4963\n",
            "Epoch 119/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 673.1326\n",
            "Epoch 120/250\n",
            "22/22 [==============================] - 0s 930us/step - loss: 650.6042\n",
            "Epoch 121/250\n",
            "22/22 [==============================] - 0s 971us/step - loss: 628.1692\n",
            "Epoch 122/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 606.9338\n",
            "Epoch 123/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 585.8941\n",
            "Epoch 124/250\n",
            "22/22 [==============================] - 0s 939us/step - loss: 569.0661\n",
            "Epoch 125/250\n",
            "22/22 [==============================] - 0s 932us/step - loss: 548.8050\n",
            "Epoch 126/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 529.5031\n",
            "Epoch 127/250\n",
            "22/22 [==============================] - 0s 916us/step - loss: 510.8260\n",
            "Epoch 128/250\n",
            "22/22 [==============================] - 0s 960us/step - loss: 492.1786\n",
            "Epoch 129/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 476.5265\n",
            "Epoch 130/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 461.0054\n",
            "Epoch 131/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 441.7250\n",
            "Epoch 132/250\n",
            "22/22 [==============================] - 0s 1000us/step - loss: 423.2190\n",
            "Epoch 133/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 407.2342\n",
            "Epoch 134/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 391.5854\n",
            "Epoch 135/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 376.6968\n",
            "Epoch 136/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 360.7474\n",
            "Epoch 137/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 344.0547\n",
            "Epoch 138/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 329.5937\n",
            "Epoch 139/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 317.4414\n",
            "Epoch 140/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 302.9960\n",
            "Epoch 141/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 287.7448\n",
            "Epoch 142/250\n",
            "22/22 [==============================] - 0s 928us/step - loss: 274.9124\n",
            "Epoch 143/250\n",
            "22/22 [==============================] - 0s 936us/step - loss: 260.6674\n",
            "Epoch 144/250\n",
            "22/22 [==============================] - 0s 947us/step - loss: 248.0251\n",
            "Epoch 145/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 234.6962\n",
            "Epoch 146/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 223.5574\n",
            "Epoch 147/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 210.4358\n",
            "Epoch 148/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 198.9363\n",
            "Epoch 149/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 188.3888\n",
            "Epoch 150/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 176.2551\n",
            "Epoch 151/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 165.7683\n",
            "Epoch 152/250\n",
            "22/22 [==============================] - 0s 991us/step - loss: 156.5522\n",
            "Epoch 153/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 148.3615\n",
            "Epoch 154/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 139.8867\n",
            "Epoch 155/250\n",
            "22/22 [==============================] - 0s 943us/step - loss: 131.2695\n",
            "Epoch 156/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 121.8537\n",
            "Epoch 157/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 114.5369\n",
            "Epoch 158/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 105.8110\n",
            "Epoch 159/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 98.5497\n",
            "Epoch 160/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 90.0742\n",
            "Epoch 161/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 83.6082\n",
            "Epoch 162/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 77.6090\n",
            "Epoch 163/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 72.0628\n",
            "Epoch 164/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 67.0301\n",
            "Epoch 165/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 62.5113\n",
            "Epoch 166/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 58.3196\n",
            "Epoch 167/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 54.6561\n",
            "Epoch 168/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 50.4826\n",
            "Epoch 169/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 47.7476\n",
            "Epoch 170/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 44.2570\n",
            "Epoch 171/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 40.8232\n",
            "Epoch 172/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 38.8992\n",
            "Epoch 173/250\n",
            "22/22 [==============================] - 0s 969us/step - loss: 36.6842\n",
            "Epoch 174/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 35.1545\n",
            "Epoch 175/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 33.3042\n",
            "Epoch 176/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 31.5908\n",
            "Epoch 177/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 30.9693\n",
            "Epoch 178/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 29.6544\n",
            "Epoch 179/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 29.6218\n",
            "Epoch 180/250\n",
            "22/22 [==============================] - 0s 975us/step - loss: 28.4355\n",
            "Epoch 181/250\n",
            "22/22 [==============================] - 0s 959us/step - loss: 27.6817\n",
            "Epoch 182/250\n",
            "22/22 [==============================] - 0s 986us/step - loss: 27.0066\n",
            "Epoch 183/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 26.4622\n",
            "Epoch 184/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 26.5388\n",
            "Epoch 185/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 26.2276\n",
            "Epoch 186/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 25.6199\n",
            "Epoch 187/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 25.3329\n",
            "Epoch 188/250\n",
            "22/22 [==============================] - 0s 941us/step - loss: 25.7967\n",
            "Epoch 189/250\n",
            "22/22 [==============================] - 0s 967us/step - loss: 24.8327\n",
            "Epoch 190/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 25.1637\n",
            "Epoch 191/250\n",
            "22/22 [==============================] - 0s 913us/step - loss: 24.6837\n",
            "Epoch 192/250\n",
            "22/22 [==============================] - 0s 982us/step - loss: 24.7032\n",
            "Epoch 193/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.7267\n",
            "Epoch 194/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.5140\n",
            "Epoch 195/250\n",
            "22/22 [==============================] - 0s 947us/step - loss: 24.7870\n",
            "Epoch 196/250\n",
            "22/22 [==============================] - 0s 973us/step - loss: 24.4993\n",
            "Epoch 197/250\n",
            "22/22 [==============================] - 0s 955us/step - loss: 24.3205\n",
            "Epoch 198/250\n",
            "22/22 [==============================] - 0s 992us/step - loss: 24.2926\n",
            "Epoch 199/250\n",
            "22/22 [==============================] - 0s 961us/step - loss: 24.4478\n",
            "Epoch 200/250\n",
            "22/22 [==============================] - 0s 966us/step - loss: 24.1472\n",
            "Epoch 201/250\n",
            "22/22 [==============================] - 0s 985us/step - loss: 24.4565\n",
            "Epoch 202/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.4604\n",
            "Epoch 203/250\n",
            "22/22 [==============================] - 0s 975us/step - loss: 24.4063\n",
            "Epoch 204/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.1587\n",
            "Epoch 205/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.0693\n",
            "Epoch 206/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.3976\n",
            "Epoch 207/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.2805\n",
            "Epoch 208/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.3455\n",
            "Epoch 209/250\n",
            "22/22 [==============================] - 0s 917us/step - loss: 24.0991\n",
            "Epoch 210/250\n",
            "22/22 [==============================] - 0s 1000us/step - loss: 24.2852\n",
            "Epoch 211/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.3711\n",
            "Epoch 212/250\n",
            "22/22 [==============================] - 0s 960us/step - loss: 24.2546\n",
            "Epoch 213/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.2478\n",
            "Epoch 214/250\n",
            "22/22 [==============================] - 0s 997us/step - loss: 24.1968\n",
            "Epoch 215/250\n",
            "22/22 [==============================] - 0s 962us/step - loss: 24.1741\n",
            "Epoch 216/250\n",
            "22/22 [==============================] - 0s 913us/step - loss: 24.1219\n",
            "Epoch 217/250\n",
            "22/22 [==============================] - 0s 962us/step - loss: 24.2201\n",
            "Epoch 218/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.4138\n",
            "Epoch 219/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.0389\n",
            "Epoch 220/250\n",
            "22/22 [==============================] - 0s 919us/step - loss: 24.0202\n",
            "Epoch 221/250\n",
            "22/22 [==============================] - 0s 982us/step - loss: 24.3834\n",
            "Epoch 222/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.5599\n",
            "Epoch 223/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.1446\n",
            "Epoch 224/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.1679\n",
            "Epoch 225/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.5299\n",
            "Epoch 226/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.1563\n",
            "Epoch 227/250\n",
            "22/22 [==============================] - 0s 998us/step - loss: 24.1360\n",
            "Epoch 228/250\n",
            "22/22 [==============================] - 0s 2ms/step - loss: 24.3827\n",
            "Epoch 229/250\n",
            "22/22 [==============================] - 0s 993us/step - loss: 23.8649\n",
            "Epoch 230/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.4080\n",
            "Epoch 231/250\n",
            "22/22 [==============================] - 0s 943us/step - loss: 24.1790\n",
            "Epoch 232/250\n",
            "22/22 [==============================] - 0s 979us/step - loss: 24.4473\n",
            "Epoch 233/250\n",
            "22/22 [==============================] - 0s 974us/step - loss: 24.5292\n",
            "Epoch 234/250\n",
            "22/22 [==============================] - 0s 936us/step - loss: 24.2001\n",
            "Epoch 235/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.3856\n",
            "Epoch 236/250\n",
            "22/22 [==============================] - 0s 979us/step - loss: 24.2351\n",
            "Epoch 237/250\n",
            "22/22 [==============================] - 0s 987us/step - loss: 24.4509\n",
            "Epoch 238/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 23.9360\n",
            "Epoch 239/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.1365\n",
            "Epoch 240/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.2005\n",
            "Epoch 241/250\n",
            "22/22 [==============================] - 0s 953us/step - loss: 24.4433\n",
            "Epoch 242/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.1298\n",
            "Epoch 243/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.5156\n",
            "Epoch 244/250\n",
            "22/22 [==============================] - 0s 980us/step - loss: 24.1245\n",
            "Epoch 245/250\n",
            "22/22 [==============================] - 0s 986us/step - loss: 24.4949\n",
            "Epoch 246/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.1270\n",
            "Epoch 247/250\n",
            "22/22 [==============================] - 0s 951us/step - loss: 24.2927\n",
            "Epoch 248/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.0318\n",
            "Epoch 249/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.7659\n",
            "Epoch 250/250\n",
            "22/22 [==============================] - 0s 1ms/step - loss: 24.1868\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tensorflow.python.keras.callbacks.History at 0x7fa5069517f0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zCN48RkgbTG5"
      },
      "source": [
        "## Evaluation\n",
        "\n",
        "Let's evaluate our performance on our training set and our test set. We can compare these two performances to check for overfitting."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AS46mC8JbTG6",
        "outputId": "4b601e29-227f-47a9-a54b-e018d388ac08"
      },
      "source": [
        "model.history.history"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'loss': [257046.02053571428,\n",
              "  256727.57410714286,\n",
              "  256522.99767857144,\n",
              "  256373.04339285713,\n",
              "  256208.80839285714,\n",
              "  256017.87419642857,\n",
              "  255794.63875,\n",
              "  255536.61446428573,\n",
              "  255246.50839285715,\n",
              "  254920.9007142857,\n",
              "  254556.80571428573,\n",
              "  254155.80767857144,\n",
              "  253712.6569642857,\n",
              "  253222.941875,\n",
              "  252682.845,\n",
              "  252086.95839285714,\n",
              "  251436.20464285713,\n",
              "  250726.11482142858,\n",
              "  249952.45232142857,\n",
              "  249109.92089285713,\n",
              "  248200.0200892857,\n",
              "  247215.95776785715,\n",
              "  246154.1205357143,\n",
              "  245005.08839285714,\n",
              "  243780.42348214285,\n",
              "  242465.37642857144,\n",
              "  241055.46339285714,\n",
              "  239559.661875,\n",
              "  237966.36696428573,\n",
              "  236272.626875,\n",
              "  234471.03642857142,\n",
              "  232554.95428571428,\n",
              "  230538.98651785715,\n",
              "  228401.81401785713,\n",
              "  226150.31267857144,\n",
              "  223783.81348214287,\n",
              "  221290.60571428572,\n",
              "  218679.40830357143,\n",
              "  215924.69125,\n",
              "  213063.56241071428,\n",
              "  210046.38044642858,\n",
              "  206900.92839285714,\n",
              "  203611.78616071428,\n",
              "  200231.52544642857,\n",
              "  196671.46205357142,\n",
              "  192974.43410714285,\n",
              "  189174.22910714286,\n",
              "  185202.64232142858,\n",
              "  181108.9913392857,\n",
              "  176864.39651785715,\n",
              "  172504.71794642857,\n",
              "  168003.58785714285,\n",
              "  163362.08651785715,\n",
              "  158614.57803571428,\n",
              "  153737.69098214287,\n",
              "  148756.86517857143,\n",
              "  143625.381875,\n",
              "  138388.08901785716,\n",
              "  133087.5436607143,\n",
              "  127688.31861607142,\n",
              "  122186.69504464285,\n",
              "  116597.92147321429,\n",
              "  110948.68290178571,\n",
              "  105236.5175,\n",
              "  99482.9940625,\n",
              "  93701.20227678571,\n",
              "  87938.2564732143,\n",
              "  82171.90580357143,\n",
              "  76383.89745535715,\n",
              "  70635.64622767858,\n",
              "  64962.11716517857,\n",
              "  59347.544352678575,\n",
              "  53863.82444196429,\n",
              "  48459.28073660714,\n",
              "  43236.19125,\n",
              "  38164.600323660714,\n",
              "  33331.563203125,\n",
              "  28683.768895089284,\n",
              "  24321.479464285716,\n",
              "  20278.469587053572,\n",
              "  16523.323091517857,\n",
              "  13159.072672991071,\n",
              "  10194.291685267857,\n",
              "  7640.408490513393,\n",
              "  5576.274188058036,\n",
              "  4007.2731919642856,\n",
              "  2910.798597935268,\n",
              "  2304.2849581473215,\n",
              "  2099.1053069196428,\n",
              "  2047.892582310268,\n",
              "  2011.3148486328125,\n",
              "  1977.7155691964285,\n",
              "  1943.7098918805802,\n",
              "  1906.4392619977677,\n",
              "  1873.7697509765626,\n",
              "  1839.494091796875,\n",
              "  1807.7019468470983,\n",
              "  1773.0187297712052,\n",
              "  1742.6450809151786,\n",
              "  1706.0910637555803,\n",
              "  1671.919691685268,\n",
              "  1640.9999825613838,\n",
              "  1610.9062388392856,\n",
              "  1579.4019182477678,\n",
              "  1545.4603473772322,\n",
              "  1518.577080078125,\n",
              "  1485.8637158203126,\n",
              "  1457.9632101004465,\n",
              "  1424.8217975725447,\n",
              "  1394.5545382254463,\n",
              "  1364.850046735491,\n",
              "  1337.1091573660715,\n",
              "  1305.234978376116,\n",
              "  1277.8466336495535,\n",
              "  1248.961134905134,\n",
              "  1218.9898291015625,\n",
              "  1188.1648325892857,\n",
              "  1159.2657979910714,\n",
              "  1131.0403955078125,\n",
              "  1098.9464425223214,\n",
              "  1068.8702406529019,\n",
              "  1034.1244656808035,\n",
              "  1004.9060944475447,\n",
              "  974.5797921316964,\n",
              "  949.073662109375,\n",
              "  925.6563427734375,\n",
              "  898.7897991071428,\n",
              "  876.443902936663,\n",
              "  846.4307498604911,\n",
              "  829.9401977539062,\n",
              "  802.4260260881697,\n",
              "  777.9862841796875,\n",
              "  751.9605353655134,\n",
              "  724.9629045758928,\n",
              "  702.3697220284598,\n",
              "  679.32080078125,\n",
              "  655.4712688337054,\n",
              "  630.956916155134,\n",
              "  608.5175149972098,\n",
              "  585.3117515345982,\n",
              "  565.7603156389509,\n",
              "  542.5648521205358,\n",
              "  520.9779725864955,\n",
              "  501.187763671875,\n",
              "  483.32678588867185,\n",
              "  466.3137942940848,\n",
              "  448.6378601074219,\n",
              "  426.9133588518415,\n",
              "  411.4831403459821,\n",
              "  393.4418805803571,\n",
              "  376.3281863839286,\n",
              "  358.0179701450893,\n",
              "  344.0322297014509,\n",
              "  327.16663940429686,\n",
              "  312.23322230747766,\n",
              "  300.4992583356585,\n",
              "  285.098472202846,\n",
              "  270.99015023367747,\n",
              "  257.9235995047433,\n",
              "  242.57313310895648,\n",
              "  228.55255998883928,\n",
              "  217.23230460030692,\n",
              "  204.03783900669643,\n",
              "  192.49236258370536,\n",
              "  181.94021946498327,\n",
              "  170.34200622558595,\n",
              "  161.14263549804687,\n",
              "  149.8765545654297,\n",
              "  140.51057817731584,\n",
              "  131.7381551688058,\n",
              "  122.92249625069755,\n",
              "  114.93649026053292,\n",
              "  107.10216094970703,\n",
              "  99.21032762799945,\n",
              "  92.26787187848772,\n",
              "  84.84226850237165,\n",
              "  78.42208199637277,\n",
              "  73.06991385323661,\n",
              "  68.88644858224052,\n",
              "  63.60992636544364,\n",
              "  59.04246122087751,\n",
              "  54.492334987095425,\n",
              "  50.56024594988142,\n",
              "  46.57507073538644,\n",
              "  43.65467989240374,\n",
              "  41.20235630580357,\n",
              "  38.54703225272043,\n",
              "  36.89274923052107,\n",
              "  35.26179874965123,\n",
              "  33.39060076032366,\n",
              "  32.297111097063336,\n",
              "  31.1116964503697,\n",
              "  29.79240364074707,\n",
              "  28.935144544328963,\n",
              "  28.26140598842076,\n",
              "  27.343234013148717,\n",
              "  27.36963134765625,\n",
              "  26.79698026384626,\n",
              "  26.499113333565848,\n",
              "  25.893150612967354,\n",
              "  25.62219348362514,\n",
              "  25.393682414463587,\n",
              "  25.434924599783763,\n",
              "  25.196334571838378,\n",
              "  25.098290459769114,\n",
              "  25.021088354928153,\n",
              "  24.9933164705549,\n",
              "  24.817250110081265,\n",
              "  24.610098855154856,\n",
              "  24.39006670815604,\n",
              "  24.064426999773296,\n",
              "  24.527889840262276,\n",
              "  24.3929073878697,\n",
              "  24.59200389317104,\n",
              "  24.290332630702427,\n",
              "  24.540304859706335,\n",
              "  24.25796793256487,\n",
              "  24.22394993373326,\n",
              "  24.33741833278111,\n",
              "  24.367307946341377,\n",
              "  24.26597143990653,\n",
              "  24.236519066946848,\n",
              "  24.03049336024693,\n",
              "  24.29250689915248,\n",
              "  24.48969031197684,\n",
              "  24.059261234828405,\n",
              "  24.20917403084891,\n",
              "  24.062846450805665,\n",
              "  24.515583092825754,\n",
              "  24.111098273141042,\n",
              "  23.9794596862793,\n",
              "  24.218495330810548,\n",
              "  24.112635650634765,\n",
              "  24.419767041887557,\n",
              "  24.22412246159145,\n",
              "  24.0720441872733,\n",
              "  24.00706672668457,\n",
              "  24.368646545410158,\n",
              "  23.988784593854632,\n",
              "  24.33735505240304,\n",
              "  24.118764997209823,\n",
              "  24.143690828595844,\n",
              "  24.061329509190152,\n",
              "  24.44786605834961,\n",
              "  24.55346090044294,\n",
              "  24.511635371616908,\n",
              "  24.26320677621024,\n",
              "  24.089111475263323,\n",
              "  23.989297572544643,\n",
              "  24.744917046683174]}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VVKzv2WBbTG9"
      },
      "source": [
        "loss = model.history.history['loss']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "F4_FmnbybTHB",
        "outputId": "1df7b7ff-f8ff-4817-b364-ab34b24ab644"
      },
      "source": [
        "sns.lineplot(x=range(len(loss)),y=loss)\n",
        "plt.title(\"Training Loss per Epoch\");"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z-6WcpUZbTHF"
      },
      "source": [
        "### Compare final evaluation (MSE) on training set and test set.\n",
        "\n",
        "These should hopefully be fairly close to each other."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SyFq319abTHF",
        "outputId": "5a3f9274-fb72-44d4-c11e-924ffa9d17bf"
      },
      "source": [
        "model.metrics_names"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['loss']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oPmAOnFQbTHI"
      },
      "source": [
        "training_score = model.evaluate(X_train,y_train,verbose=0)\n",
        "test_score = model.evaluate(X_test,y_test,verbose=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6YZetdptbTHL",
        "outputId": "46fad9cb-94e2-49b2-a0ba-81ee993df81d"
      },
      "source": [
        "training_score"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24.55682439531599"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xalJcATebTHO",
        "outputId": "52c4a03f-d1e6-4346-8cff-05eb5caf79ac"
      },
      "source": [
        "test_score"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "26.798187001546225"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x1HXnv2_bTHR"
      },
      "source": [
        "### Further Evaluations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_J2G32CFbTHS"
      },
      "source": [
        "test_predictions = model.predict(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "67M8frWbbTHV",
        "outputId": "de830055-69a5-47e9-fc6b-71932184e0c4"
      },
      "source": [
        "test_predictions"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[406.26343],\n",
              "       [625.07983],\n",
              "       [593.59314],\n",
              "       [573.62714],\n",
              "       [367.47824],\n",
              "       [580.6027 ],\n",
              "       [516.3    ],\n",
              "       [460.22568],\n",
              "       [550.58673],\n",
              "       [448.60873],\n",
              "       [613.2959 ],\n",
              "       [550.30396],\n",
              "       [420.10864],\n",
              "       [409.8501 ],\n",
              "       [652.86633],\n",
              "       [438.35947],\n",
              "       [509.70355],\n",
              "       [661.5566 ],\n",
              "       [664.221  ],\n",
              "       [566.93195],\n",
              "       [335.011  ],\n",
              "       [445.90964],\n",
              "       [383.43677],\n",
              "       [379.66046],\n",
              "       [567.987  ],\n",
              "       [612.09296],\n",
              "       [533.69293],\n",
              "       [428.89386],\n",
              "       [657.0607 ],\n",
              "       [415.08276],\n",
              "       [443.71158],\n",
              "       [486.30923],\n",
              "       [439.4752 ],\n",
              "       [683.53503],\n",
              "       [425.78995],\n",
              "       [418.6874 ],\n",
              "       [503.1647 ],\n",
              "       [551.8273 ],\n",
              "       [510.96967],\n",
              "       [396.29428],\n",
              "       [620.1216 ],\n",
              "       [417.63516],\n",
              "       [605.9426 ],\n",
              "       [447.04782],\n",
              "       [503.214  ],\n",
              "       [583.16064],\n",
              "       [670.66925],\n",
              "       [491.6024 ],\n",
              "       [319.3331 ],\n",
              "       [486.60828],\n",
              "       [518.5312 ],\n",
              "       [382.71024],\n",
              "       [543.24634],\n",
              "       [409.57797],\n",
              "       [643.1107 ],\n",
              "       [492.27206],\n",
              "       [629.48804],\n",
              "       [628.5606 ],\n",
              "       [448.15475],\n",
              "       [485.87952],\n",
              "       [492.33035],\n",
              "       [475.69794],\n",
              "       [684.4861 ],\n",
              "       [404.25476],\n",
              "       [702.8802 ],\n",
              "       [587.84174],\n",
              "       [584.55994],\n",
              "       [539.17975],\n",
              "       [485.75665],\n",
              "       [517.82074],\n",
              "       [362.08646],\n",
              "       [542.08276],\n",
              "       [572.03156],\n",
              "       [529.7627 ],\n",
              "       [454.82465],\n",
              "       [532.44696],\n",
              "       [508.45544],\n",
              "       [444.4056 ],\n",
              "       [544.70044],\n",
              "       [642.3479 ],\n",
              "       [467.1369 ],\n",
              "       [568.65845],\n",
              "       [692.49036],\n",
              "       [459.848  ],\n",
              "       [710.67194],\n",
              "       [473.8478 ],\n",
              "       [404.25616],\n",
              "       [586.54626],\n",
              "       [437.8215 ],\n",
              "       [490.16046],\n",
              "       [618.5658 ],\n",
              "       [440.54614],\n",
              "       [456.4309 ],\n",
              "       [436.31238],\n",
              "       [508.1484 ],\n",
              "       [609.9504 ],\n",
              "       [322.3879 ],\n",
              "       [437.33047],\n",
              "       [537.66205],\n",
              "       [519.9028 ],\n",
              "       [606.54333],\n",
              "       [526.7351 ],\n",
              "       [334.9314 ],\n",
              "       [577.5914 ],\n",
              "       [432.82236],\n",
              "       [563.9483 ],\n",
              "       [514.66473],\n",
              "       [392.0228 ],\n",
              "       [567.6409 ],\n",
              "       [455.911  ],\n",
              "       [449.57327],\n",
              "       [642.5517 ],\n",
              "       [525.6672 ],\n",
              "       [552.0467 ],\n",
              "       [418.70322],\n",
              "       [479.90872],\n",
              "       [587.9719 ],\n",
              "       [669.03143],\n",
              "       [702.20355],\n",
              "       [661.02466],\n",
              "       [561.94727],\n",
              "       [504.41043],\n",
              "       [391.29007],\n",
              "       [281.9948 ],\n",
              "       [480.78778],\n",
              "       [617.9032 ],\n",
              "       [374.2134 ],\n",
              "       [513.51825],\n",
              "       [512.27576],\n",
              "       [494.6914 ],\n",
              "       [481.63385],\n",
              "       [424.8122 ],\n",
              "       [494.66434],\n",
              "       [472.623  ],\n",
              "       [601.9391 ],\n",
              "       [575.005  ],\n",
              "       [415.9636 ],\n",
              "       [632.2133 ],\n",
              "       [467.5123 ],\n",
              "       [565.7332 ],\n",
              "       [406.6662 ],\n",
              "       [533.484  ],\n",
              "       [574.05035],\n",
              "       [357.92883],\n",
              "       [551.1896 ],\n",
              "       [604.85095],\n",
              "       [385.2252 ],\n",
              "       [543.72565],\n",
              "       [563.984  ],\n",
              "       [453.99207],\n",
              "       [633.7756 ],\n",
              "       [373.1417 ],\n",
              "       [475.4092 ],\n",
              "       [530.16583],\n",
              "       [373.19534],\n",
              "       [462.35925],\n",
              "       [437.36887],\n",
              "       [499.71695],\n",
              "       [346.94308],\n",
              "       [396.24692],\n",
              "       [606.0831 ],\n",
              "       [507.89963],\n",
              "       [469.75818],\n",
              "       [491.5713 ],\n",
              "       [536.60364],\n",
              "       [345.31842],\n",
              "       [513.5915 ],\n",
              "       [251.38142],\n",
              "       [505.32523],\n",
              "       [542.43054],\n",
              "       [490.56903],\n",
              "       [472.24612],\n",
              "       [393.4955 ],\n",
              "       [417.26862],\n",
              "       [550.93176],\n",
              "       [476.95383],\n",
              "       [581.37994],\n",
              "       [490.9674 ],\n",
              "       [602.4701 ],\n",
              "       [548.3496 ],\n",
              "       [543.30194],\n",
              "       [501.8112 ],\n",
              "       [647.44324],\n",
              "       [561.8009 ],\n",
              "       [579.37555],\n",
              "       [445.2174 ],\n",
              "       [416.52985],\n",
              "       [421.0515 ],\n",
              "       [570.5346 ],\n",
              "       [610.52203],\n",
              "       [438.8255 ],\n",
              "       [489.1685 ],\n",
              "       [589.20416],\n",
              "       [526.6729 ],\n",
              "       [358.21768],\n",
              "       [647.02264],\n",
              "       [529.33215],\n",
              "       [338.01492],\n",
              "       [493.89966],\n",
              "       [411.1523 ],\n",
              "       [608.1084 ],\n",
              "       [347.3649 ],\n",
              "       [523.7079 ],\n",
              "       [405.67038],\n",
              "       [259.00522],\n",
              "       [521.17804],\n",
              "       [341.71494],\n",
              "       [362.9102 ],\n",
              "       [577.8506 ],\n",
              "       [417.68906],\n",
              "       [552.3458 ],\n",
              "       [522.365  ],\n",
              "       [512.0057 ],\n",
              "       [325.52286],\n",
              "       [405.12326],\n",
              "       [603.8921 ],\n",
              "       [619.39307],\n",
              "       [604.7606 ],\n",
              "       [567.6965 ],\n",
              "       [474.58182],\n",
              "       [461.4935 ],\n",
              "       [509.68094],\n",
              "       [446.99258],\n",
              "       [512.57574],\n",
              "       [503.60657],\n",
              "       [401.1072 ],\n",
              "       [607.0318 ],\n",
              "       [258.73117],\n",
              "       [629.81726],\n",
              "       [590.60266],\n",
              "       [327.92664],\n",
              "       [480.71942],\n",
              "       [596.82367],\n",
              "       [379.30722],\n",
              "       [461.27716],\n",
              "       [325.78357],\n",
              "       [519.9732 ],\n",
              "       [410.61462],\n",
              "       [557.62585],\n",
              "       [643.49084],\n",
              "       [538.1467 ],\n",
              "       [504.41574],\n",
              "       [636.6225 ],\n",
              "       [516.51086],\n",
              "       [533.0186 ],\n",
              "       [520.09735],\n",
              "       [458.5575 ],\n",
              "       [507.0747 ],\n",
              "       [462.23328],\n",
              "       [593.1741 ],\n",
              "       [467.04837],\n",
              "       [428.21533],\n",
              "       [542.92456],\n",
              "       [495.01172],\n",
              "       [681.3526 ],\n",
              "       [373.66132],\n",
              "       [552.9735 ],\n",
              "       [579.3976 ],\n",
              "       [435.0165 ],\n",
              "       [544.3619 ],\n",
              "       [587.45667],\n",
              "       [580.6866 ],\n",
              "       [722.74384],\n",
              "       [433.78827],\n",
              "       [399.55917],\n",
              "       [314.75165],\n",
              "       [449.3715 ],\n",
              "       [389.0275 ],\n",
              "       [544.5414 ],\n",
              "       [524.0208 ],\n",
              "       [565.89056],\n",
              "       [449.10574],\n",
              "       [535.72797],\n",
              "       [382.709  ],\n",
              "       [502.7475 ],\n",
              "       [638.6875 ],\n",
              "       [497.77362],\n",
              "       [569.79364],\n",
              "       [471.25647],\n",
              "       [273.95135],\n",
              "       [518.6328 ],\n",
              "       [622.9433 ],\n",
              "       [351.34857],\n",
              "       [451.53647],\n",
              "       [500.51117],\n",
              "       [544.3127 ],\n",
              "       [613.3484 ],\n",
              "       [389.1045 ],\n",
              "       [450.48734],\n",
              "       [483.59534],\n",
              "       [599.79675],\n",
              "       [500.60007],\n",
              "       [322.21704],\n",
              "       [556.5154 ],\n",
              "       [445.71307],\n",
              "       [530.3348 ],\n",
              "       [516.57184],\n",
              "       [611.15717],\n",
              "       [417.96445],\n",
              "       [411.85953]], dtype=float32)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DoqASGqdbTHY"
      },
      "source": [
        "pred_df = pd.DataFrame(y_test,columns=['Test Y'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Lw1MZd81bTHb",
        "outputId": "c70c0dc0-cbd2-4507-d778-b6dde6d7e8ec"
      },
      "source": [
        "pred_df"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Test Y</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>402.296319</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>624.156198</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>582.455066</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>578.588606</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>371.224104</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>295</th>\n",
              "      <td>525.704657</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>296</th>\n",
              "      <td>502.909473</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>297</th>\n",
              "      <td>612.727910</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>298</th>\n",
              "      <td>417.569725</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>299</th>\n",
              "      <td>410.538250</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>300 rows × 1 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "         Test Y\n",
              "0    402.296319\n",
              "1    624.156198\n",
              "2    582.455066\n",
              "3    578.588606\n",
              "4    371.224104\n",
              "..          ...\n",
              "295  525.704657\n",
              "296  502.909473\n",
              "297  612.727910\n",
              "298  417.569725\n",
              "299  410.538250\n",
              "\n",
              "[300 rows x 1 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wl_Cg3QobTHe"
      },
      "source": [
        "test_predictions = pd.Series(test_predictions.reshape(300,))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4dShm50lbTHh",
        "outputId": "fb50ec06-58c6-42e6-f06f-28d0a3ebaf0d"
      },
      "source": [
        "test_predictions"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0      406.263428\n",
              "1      625.079834\n",
              "2      593.593140\n",
              "3      573.627136\n",
              "4      367.478241\n",
              "          ...    \n",
              "295    530.334778\n",
              "296    516.571838\n",
              "297    611.157166\n",
              "298    417.964447\n",
              "299    411.859528\n",
              "Length: 300, dtype: float32"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0LHxCkTqbTHo"
      },
      "source": [
        "pred_df = pd.concat([pred_df,test_predictions],axis=1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FvZSCzsbbTHz"
      },
      "source": [
        "pred_df.columns = ['Test Y','Model Predictions']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tj6v1aeFbTH5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 419
        },
        "outputId": "4f7cb34d-8597-49ce-8df2-a3bb6a39cbee"
      },
      "source": [
        "pred_df"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Test Y</th>\n",
              "      <th>Model Predictions</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>402.296319</td>\n",
              "      <td>404.944824</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>624.156198</td>\n",
              "      <td>623.190002</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>582.455066</td>\n",
              "      <td>591.782837</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>578.588606</td>\n",
              "      <td>571.877747</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>371.224104</td>\n",
              "      <td>366.272583</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>295</th>\n",
              "      <td>525.704657</td>\n",
              "      <td>528.697449</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>296</th>\n",
              "      <td>502.909473</td>\n",
              "      <td>514.984314</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>297</th>\n",
              "      <td>612.727910</td>\n",
              "      <td>609.302307</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>298</th>\n",
              "      <td>417.569725</td>\n",
              "      <td>416.609833</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>299</th>\n",
              "      <td>410.538250</td>\n",
              "      <td>410.530823</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>300 rows × 2 columns</p>\n",
              "</div>"
            ],
            "text/plain": [
              "         Test Y  Model Predictions\n",
              "0    402.296319         404.944824\n",
              "1    624.156198         623.190002\n",
              "2    582.455066         591.782837\n",
              "3    578.588606         571.877747\n",
              "4    371.224104         366.272583\n",
              "..          ...                ...\n",
              "295  525.704657         528.697449\n",
              "296  502.909473         514.984314\n",
              "297  612.727910         609.302307\n",
              "298  417.569725         416.609833\n",
              "299  410.538250         410.530823\n",
              "\n",
              "[300 rows x 2 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qdyQoH3ZbTH8"
      },
      "source": [
        "Let's compare to the real test labels!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K8l_yllubTH-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        },
        "outputId": "c7ccf6c0-0ea8-4810-e0ea-f837bff038e2"
      },
      "source": [
        "sns.scatterplot(x='Test Y',y='Model Predictions',data=pred_df)\n",
        "#sns.scatterplot(data=pred_df)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7fa505fa46d8>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nBolAntzbTII"
      },
      "source": [
        "pred_df['Error'] = pred_df['Test Y'] - pred_df['Model Predictions']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Il7LDc8PbTIP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 296
        },
        "outputId": "c6f0645e-6983-494d-d581-2af14a03fd21"
      },
      "source": [
        "sns.distplot(pred_df['Error'],bins=50)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7fa504170208>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wzWVSJ74bTIT"
      },
      "source": [
        "from sklearn.metrics import mean_absolute_error,mean_squared_error"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "y6d2EjF6bTIW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "62d5a8a5-957c-421a-b1c4-67c1bfaf1b82"
      },
      "source": [
        "mean_absolute_error(pred_df['Test Y'],pred_df['Model Predictions'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4.000806359622792"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hDBqvUCAbTIb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "73e5274a-40d9-47aa-977f-0d96792e60ca"
      },
      "source": [
        "mean_squared_error(pred_df['Test Y'],pred_df['Model Predictions'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24.99533991966788"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZuHetz1NbTIf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "94119304-6c13-4973-a815-e3e458acea68"
      },
      "source": [
        "# Essentially the same thing, difference just due to precision\n",
        "test_score"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24.995363235473633"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "odnlodLRbTIi",
        "outputId": "a9896af7-10bb-4157-f7ef-920d4c9b948e"
      },
      "source": [
        "#RMSE\n",
        "test_score**0.5"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.176696533654085"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0oqN8sYGbTIr"
      },
      "source": [
        "# Predicting on brand new data\n",
        "\n",
        "What if we just saw a brand new gemstone from the ground? What should we price it at? This is the **exact** same procedure as predicting on a new test data!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AF5IrdxQbTIs"
      },
      "source": [
        "# [[Feature1, Feature2]]\n",
        "new_gem = [[998,1000]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B7ZH2bzLbTIw",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6379de52-3926-4f06-d05b-d346c8e6fa36"
      },
      "source": [
        "# Don't forget to scale!\n",
        "scaler.transform(new_gem)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.14117652, 0.53968792]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ULvPFV4ybTI3"
      },
      "source": [
        "new_gem = scaler.transform(new_gem)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C-_hmj30bTI-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c75f68c2-c71b-40ec-e7b0-76599ce0fdcb"
      },
      "source": [
        "model.predict(new_gem)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[419.34152]], dtype=float32)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r3rPpgMpbTJC"
      },
      "source": [
        "## Saving and Loading a Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ci0eJL4KbTJD"
      },
      "source": [
        "from tensorflow.keras.models import load_model"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OfAjHmOibTJG"
      },
      "source": [
        "model.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hm5gylHAbTJI"
      },
      "source": [
        "later_model = load_model('my_model.h5')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2OkipIoRbTJM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 163
        },
        "outputId": "686cbc01-65d4-4176-ef7d-4494aa1d7002"
      },
      "source": [
        "later_model.predict(new_gem)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-162be03452fc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlater_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_gem\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'later_model' is not defined"
          ]
        }
      ]
    }
  ]
}