19-01 Keras-Syntax-Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://www.pieriandata.com\"><img src=\"../Pierian_Data_Logo.PNG\"></a>\n",
    "<strong><center>Copyright by Pierian Data Inc.</center></strong> \n",
    "<strong><center>Created by Jose Marcial Portilla.</center></strong>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "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",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('data/fake_reg.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "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"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.PairGrid at 0x7f616178b150>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 540x540 with 12 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.pairplot(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comment: \n",
    "Based on the charts we can see that `feature2` and `price` have a high correlation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "source": [
    "### Test/Train Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(700, 2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(300, 2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(700,)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(300,)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class MinMaxScaler in module sklearn.preprocessing._data:\n",
      "\n",
      "class MinMaxScaler(sklearn.base.TransformerMixin, sklearn.base.BaseEstimator)\n",
      " |  MinMaxScaler(feature_range=(0, 1), copy=True)\n",
      " |  \n",
      " |  Transform 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 : bool, 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 of shape (n_features,)\n",
      " |      Per feature adjustment for minimum. Equivalent to\n",
      " |      ``min - X.min(axis=0) * self.scale_``\n",
      " |  \n",
      " |  scale_ : ndarray of 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 of shape (n_features,)\n",
      " |      Per feature minimum seen in the data\n",
      " |  \n",
      " |      .. versionadded:: 0.17\n",
      " |         *data_min_*\n",
      " |  \n",
      " |  data_max_ : ndarray of shape (n_features,)\n",
      " |      Per feature maximum seen in the data\n",
      " |  \n",
      " |      .. versionadded:: 0.17\n",
      " |         *data_max_*\n",
      " |  \n",
      " |  data_range_ : ndarray of 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",
      " |  n_samples_seen_ : int\n",
      " |      The number of samples processed by the estimator.\n",
      " |      It will be reset on new calls to fit, but increments across\n",
      " |      ``partial_fit`` calls.\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()\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.TransformerMixin\n",
      " |      sklearn.base.BaseEstimator\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 of 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",
      " |      y : None\n",
      " |          Ignored.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self : object\n",
      " |          Fitted scaler.\n",
      " |  \n",
      " |  inverse_transform(self, X)\n",
      " |      Undo the scaling of X according to feature_range.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array-like of shape (n_samples, n_features)\n",
      " |          Input data that will be transformed. It cannot be sparse.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Xt : array-like of shape (n_samples, n_features)\n",
      " |          Transformed data.\n",
      " |  \n",
      " |  partial_fit(self, X, y=None)\n",
      " |      Online computation of min and max on X for later scaling.\n",
      " |      \n",
      " |      All of X is processed as a single batch. This is intended for cases\n",
      " |      when :meth:`fit` is not feasible due to very large number of\n",
      " |      `n_samples` or because X is read from a continuous stream.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array-like of 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 : None\n",
      " |          Ignored.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self : object\n",
      " |          Transformer instance.\n",
      " |  \n",
      " |  transform(self, X)\n",
      " |      Scale features of X according to feature_range.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ----------\n",
      " |      X : array-like of shape (n_samples, n_features)\n",
      " |          Input data that will be transformed.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      Xt : array-like of shape (n_samples, n_features)\n",
      " |          Transformed data.\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",
      " |      **fit_params : dict\n",
      " |          Additional fit parameters.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      X_new : numpy array of shape [n_samples, n_features_new]\n",
      " |          Transformed array.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sklearn.base.TransformerMixin:\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.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 : bool, default=True\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",
      " |      Parameters\n",
      " |      ----------\n",
      " |      **params : dict\n",
      " |          Estimator parameters.\n",
      " |      \n",
      " |      Returns\n",
      " |      -------\n",
      " |      self : object\n",
      " |          Estimator instance.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(MinMaxScaler)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = MinMaxScaler()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MinMaxScaler(copy=True, feature_range=(0, 1))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Notice to prevent data leakage from the test set, we only fit our scaler to the training set\n",
    "scaler.fit(X_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = scaler.transform(X_train)\n",
    "X_test = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": [
     "outputPrepend"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "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(*args, **kwargs)\n",
      " |  \n",
      " |  `Sequential` groups a linear stack of layers into a `tf.keras.Model`.\n",
      " |  \n",
      " |  `Sequential` provides training and inference features on this model.\n",
      " |  \n",
      " |  Examples:\n",
      " |  \n",
      " |  >>> # Optionally, the first layer can receive an `input_shape` argument:\n",
      " |  >>> model = tf.keras.Sequential()\n",
      " |  >>> model.add(tf.keras.layers.Dense(8, input_shape=(16,)))\n",
      " |  >>> # Afterwards, we do automatic shape inference:\n",
      " |  >>> model.add(tf.keras.layers.Dense(4))\n",
      " |  \n",
      " |  >>> # This is identical to the following:\n",
      " |  >>> model = tf.keras.Sequential()\n",
      " |  >>> model.add(tf.keras.layers.Dense(8, input_dim=16))\n",
      " |  \n",
      " |  >>> # And to the following:\n",
      " |  >>> model = tf.keras.Sequential()\n",
      " |  >>> model.add(tf.keras.layers.Dense(8, batch_input_shape=(None, 16)))\n",
      " |  \n",
      " |  >>> # Note that you can also omit the `input_shape` argument.\n",
      " |  >>> # In that case 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 = tf.keras.Sequential()\n",
      " |  >>> model.add(tf.keras.layers.Dense(8))\n",
      " |  >>> model.add(tf.keras.layers.Dense(4))\n",
      " |  >>> # model.weights not created yet\n",
      " |  \n",
      " |  >>> # Whereas if you specify the input shape, the model gets built\n",
      " |  >>> # continuously as you are adding layers:\n",
      " |  >>> model = tf.keras.Sequential()\n",
      " |  >>> model.add(tf.keras.layers.Dense(8, input_shape=(16,)))\n",
      " |  >>> model.add(tf.keras.layers.Dense(4))\n",
      " |  >>> len(model.weights)\n",
      " |  4\n",
      " |  \n",
      " |  >>> # When using the delayed-build pattern (no input shape specified), you can\n",
      " |  >>> # choose to manually build your model by calling\n",
      " |  >>> # `build(batch_input_shape)`:\n",
      " |  >>> model = tf.keras.Sequential()\n",
      " |  >>> model.add(tf.keras.layers.Dense(8))\n",
      " |  >>> model.add(tf.keras.layers.Dense(4))\n",
      " |  >>> model.build((None, 16))\n",
      " |  >>> len(model.weights)\n",
      " |  4\n",
      " |  \n",
      " |  ```python\n",
      " |  # Note that when using the delayed-build pattern (no input shape specified),\n",
      " |  # the model gets built the first time you call `fit` (or other training and\n",
      " |  # evaluation methods).\n",
      " |  model = tf.keras.Sequential()\n",
      " |  model.add(tf.keras.layers.Dense(8))\n",
      " |  model.add(tf.keras.layers.Dense(1))\n",
      " |  model.compile(optimizer='sgd', loss='mse')\n",
      " |  # This builds the model for the first time:\n",
      " |  model.fit(x, y, batch_size=32, epochs=10)\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",
      " |      tensorflow.python.keras.utils.version_utils.LayerVersionSelector\n",
      " |      tensorflow.python.keras.utils.version_utils.ModelVersionSelector\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, layers=None, name=None)\n",
      " |      Creates a `Sequential` model instance.\n",
      " |      \n",
      " |      Args:\n",
      " |        layers: Optional list of layers to add to the model.\n",
      " |        name: Optional name for the model.\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. (deprecated)\n",
      " |      \n",
      " |      Warning: THIS FUNCTION IS DEPRECATED. It will be removed after 2021-01-01.\n",
      " |      Instructions for updating:\n",
      " |      Please use instead:* `np.argmax(model.predict(x), axis=-1)`,   if your model does multi-class classification   (e.g. if it uses a `softmax` last-layer activation).* `(model.predict(x) > 0.5).astype(\"int32\")`,   if your model does binary classification   (e.g. if it uses a `sigmoid` last-layer activation).\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. (deprecated)\n",
      " |      \n",
      " |      Warning: THIS FUNCTION IS DEPRECATED. It will be removed after 2021-01-01.\n",
      " |      Instructions for updating:\n",
      " |      Please use `model.predict()` instead.\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",
      " |      Whether the layer is dynamic (eager-only); set in the constructor.\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, **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.keras.losses.Loss` instance. See `tf.keras.losses`.\n",
      " |              An objective function is any callable with the signature\n",
      " |              `loss = fn(y_true, y_pred)`, where\n",
      " |              y_true = ground truth values with shape = `[batch_size, d0, .. dN]`,\n",
      " |              except sparse loss functions such as sparse categorical crossentropy\n",
      " |              where shape = `[batch_size, d0, .. dN-1]`.\n",
      " |              y_pred = predicted values with shape = `[batch_size, d0, .. dN]`.\n",
      " |              It returns a weighted loss float tensor.\n",
      " |              If a custom `Loss` instance is used and reduction is set to NONE,\n",
      " |              return value has the shape [batch_size, d0, .. dN-1] ie. per-sample\n",
      " |              or per-timestep loss values; otherwise, it is a scalar.\n",
      " |              If the model has multiple outputs, you can use a different loss on\n",
      " |              each output by passing a dictionary or a list of losses. The loss\n",
      " |              value that will be minimized by the model will then be the sum of\n",
      " |              all individual losses.\n",
      " |          metrics: List of metrics to be evaluated by the model during training\n",
      " |              and testing.\n",
      " |              Each of this can be a string (name of a built-in function), function\n",
      " |              or a `tf.keras.metrics.Metric` instance. See `tf.keras.metrics`.\n",
      " |              Typically you will use `metrics=['accuracy']`. A function is any\n",
      " |              callable with the signature `result = fn(y_true, y_pred)`.\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",
      " |              When you pass the strings 'accuracy' or 'acc', we convert this to\n",
      " |              one of `tf.keras.metrics.BinaryAccuracy`,\n",
      " |              `tf.keras.metrics.CategoricalAccuracy`,\n",
      " |              `tf.keras.metrics.SparseCategoricalAccuracy` based on the loss\n",
      " |              function used and the model output shape. We do a similar conversion\n",
      " |              for the strings 'crossentropy' and 'ce' as well.\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 dict, 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",
      " |          **kwargs: Any additional arguments. For eager execution, pass\n",
      " |              `run_eagerly=True`.\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, return_dict=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: - A Numpy array (or array-like), or a list\n",
      " |            of arrays (in case the model has multiple inputs). - A TensorFlow\n",
      " |            tensor, or a list of tensors (in case the model has multiple inputs).\n",
      " |            - A dict mapping input names to the corresponding array/tensors, if\n",
      " |            the model has named inputs. - A `tf.data` dataset. - A generator or\n",
      " |            `keras.utils.Sequence` instance. A more detailed description of\n",
      " |            unpacking behavior for iterator types (Dataset, generator, Sequence)\n",
      " |            is given in the `Unpacking behavior for iterator-like inputs` section\n",
      " |            of `Model.fit`.\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, generator or `keras.utils.Sequence` instance, `y`\n",
      " |            should not be specified (since targets will be obtained from the\n",
      " |            iterator/dataset).\n",
      " |          batch_size: Integer or `None`. Number of samples per gradient update. If\n",
      " |            unspecified, `batch_size` will default to 32. Do not specify the\n",
      " |            `batch_size` if your data is in the form of a dataset, generators,\n",
      " |            or `keras.utils.Sequence` instances (since they generate batches).\n",
      " |          verbose: 0 or 1. Verbosity mode. 0 = silent, 1 = progress bar.\n",
      " |          sample_weight: Optional Numpy array of weights for the test samples,\n",
      " |            used for weighting the loss function. 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), or 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\n",
      " |                of every sample. In this case you should make sure to specify\n",
      " |                `sample_weight_mode=\"temporal\"` in `compile()`. This argument is\n",
      " |                not supported when `x` is a dataset, instead pass sample weights\n",
      " |                as the third element of `x`.\n",
      " |          steps: Integer or `None`. Total number of steps (batches of samples)\n",
      " |            before declaring the evaluation round finished. Ignored with the\n",
      " |            default value of `None`. If x is a `tf.data` dataset and `steps` is\n",
      " |            None, 'evaluate' will run until the dataset is exhausted. This\n",
      " |            argument is not supported with array inputs.\n",
      " |          callbacks: List of `keras.callbacks.Callback` instances. List of\n",
      " |            callbacks to apply during evaluation. See\n",
      " |            [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. If unspecified,\n",
      " |            `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 process-based\n",
      " |            threading. If unspecified, `workers` will default to 1. If 0, will\n",
      " |            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 the\n",
      " |            generator as they can't be passed easily to children processes.\n",
      " |          return_dict: If `True`, loss and metric results are returned as a dict,\n",
      " |            with each key being the name of the metric. If `False`, they are\n",
      " |            returned as a list.\n",
      " |      \n",
      " |      See the discussion of `Unpacking behavior for iterator-like inputs` for\n",
      " |      `Model.fit`.\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. (deprecated)\n",
      " |      \n",
      " |      Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\n",
      " |      Instructions for updating:\n",
      " |      Please use Model.evaluate, which supports generators.\n",
      " |      \n",
      " |      DEPRECATED:\n",
      " |        `Model.evaluate` now supports generators, so there is no longer any need\n",
      " |        to use this endpoint.\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_batch_size=None, validation_freq=1, max_queue_size=10, workers=1, use_multiprocessing=False)\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",
      " |            A more detailed description of unpacking behavior for iterator types\n",
      " |            (Dataset, generator, Sequence) is given below.\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 datasets, generators, or `keras.utils.Sequence` instances\n",
      " |              (since they generate 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` could be provided.\n",
      " |              Note that `validation_data` does not support all the data types that\n",
      " |              are supported in `x`, eg, dict, generator or `keras.utils.Sequence`.\n",
      " |          shuffle: Boolean (whether to shuffle the training data\n",
      " |              before each epoch) or str (for 'batch'). This argument is ignored\n",
      " |              when `x` is a generator. 'batch' is a special option for dealing\n",
      " |              with the limitations of HDF5 data; it shuffles in batch-sized\n",
      " |              chunks. 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",
      " |              When passing an infinitely repeating dataset, you must specify the\n",
      " |              `steps_per_epoch` argument. This argument is not supported with\n",
      " |              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_steps' is None, validation\n",
      " |              will run until the `validation_data` dataset is exhausted. In the\n",
      " |              case of an infinitely repeated dataset, it will run into an\n",
      " |              infinite loop. If 'validation_steps' is specified and only part of\n",
      " |              the dataset will be consumed, the evaluation will start from the\n",
      " |              beginning of the dataset at each epoch. This ensures that the same\n",
      " |              validation samples are used every time.\n",
      " |          validation_batch_size: Integer or `None`.\n",
      " |              Number of samples per validation batch.\n",
      " |              If unspecified, will default to `batch_size`.\n",
      " |              Do not specify the `validation_batch_size` if your data is in the\n",
      " |              form of datasets, generators, or `keras.utils.Sequence` instances\n",
      " |              (since they generate batches).\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",
      " |      \n",
      " |      Unpacking behavior for iterator-like inputs:\n",
      " |          A common pattern is to pass a tf.data.Dataset, generator, or\n",
      " |        tf.keras.utils.Sequence to the `x` argument of fit, which will in fact\n",
      " |        yield not only features (x) but optionally targets (y) and sample weights.\n",
      " |        Keras requires that the output of such iterator-likes be unambiguous. The\n",
      " |        iterator should return a tuple of length 1, 2, or 3, where the optional\n",
      " |        second and third elements will be used for y and sample_weight\n",
      " |        respectively. Any other type provided will be wrapped in a length one\n",
      " |        tuple, effectively treating everything as 'x'. When yielding dicts, they\n",
      " |        should still adhere to the top-level tuple structure.\n",
      " |        e.g. `({\"x0\": x0, \"x1\": x1}, y)`. Keras will not attempt to separate\n",
      " |        features, targets, and weights from the keys of a single dict.\n",
      " |          A notable unsupported data type is the namedtuple. The reason is that\n",
      " |        it behaves like both an ordered datatype (tuple) and a mapping\n",
      " |        datatype (dict). So given a namedtuple of the form:\n",
      " |            `namedtuple(\"example_tuple\", [\"y\", \"x\"])`\n",
      " |        it is ambiguous whether to reverse the order of the elements when\n",
      " |        interpreting the value. Even worse is a tuple of the form:\n",
      " |            `namedtuple(\"other_tuple\", [\"x\", \"y\", \"z\"])`\n",
      " |        where it is unclear if the tuple was intended to be unpacked into x, y,\n",
      " |        and sample_weight or passed through as a single element to `x`. As a\n",
      " |        result the data processing code will simply raise a ValueError if it\n",
      " |        encounters a namedtuple. (Along with instructions to remedy the issue.)\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. (deprecated)\n",
      " |      \n",
      " |      Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\n",
      " |      Instructions for updating:\n",
      " |      Please use Model.fit, which supports generators.\n",
      " |      \n",
      " |      DEPRECATED:\n",
      " |        `Model.fit` now supports generators, so there is no longer any need to use\n",
      " |        this endpoint.\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, skip_mismatch=False)\n",
      " |      Loads all layer weights, either from a TensorFlow or an HDF5 weight file.\n",
      " |      \n",
      " |      If `by_name` is False weights are loaded based on the network's\n",
      " |      topology. This means the architecture should be the same as when the weights\n",
      " |      were saved.  Note that layers that don't have weights are not taken into\n",
      " |      account in the topological ordering, so adding or removing layers is fine as\n",
      " |      long as they don't have weights.\n",
      " |      \n",
      " |      If `by_name` is True, weights are loaded into layers only if they share the\n",
      " |      same name. This is useful for fine-tuning or transfer-learning models where\n",
      " |      some of the layers have changed.\n",
      " |      \n",
      " |      Only topological loading (`by_name=False`) is supported when loading weights\n",
      " |      from the TensorFlow format. Note that topological loading differs slightly\n",
      " |      between TensorFlow and HDF5 formats for user-defined classes inheriting from\n",
      " |      `tf.keras.Model`: HDF5 loads based on a flattened list of weights, while the\n",
      " |      TensorFlow format loads based on the object-local names of attributes to\n",
      " |      which layers are assigned in the `Model`'s constructor.\n",
      " |      \n",
      " |      Arguments:\n",
      " |          filepath: String, path to the weights file to load. For weight files in\n",
      " |              TensorFlow format, this is the file prefix (the same as was passed\n",
      " |              to `save_weights`).\n",
      " |          by_name: Boolean, whether to load weights by name or by topological\n",
      " |              order. Only topological loading is supported for weight files in\n",
      " |              TensorFlow format.\n",
      " |          skip_mismatch: Boolean, whether to skip loading of layers where there is\n",
      " |              a mismatch in the number of weights, or a mismatch in the shape of\n",
      " |              the weight (only valid when `by_name=True`).\n",
      " |      \n",
      " |      Returns:\n",
      " |          When loading a weight file in TensorFlow format, returns the same status\n",
      " |          object as `tf.train.Checkpoint.restore`. When graph building, restore\n",
      " |          ops are run automatically as soon as the network is built (on first call\n",
      " |          for user-defined classes inheriting from `Model`, immediately if it is\n",
      " |          already built).\n",
      " |      \n",
      " |          When loading weights in HDF5 format, returns `None`.\n",
      " |      \n",
      " |      Raises:\n",
      " |          ImportError: If h5py is not available and the weight file is in HDF5\n",
      " |              format.\n",
      " |          ValueError: If `skip_mismatch` is set to `True` when `by_name` is\n",
      " |            `False`.\n",
      " |  \n",
      " |  make_predict_function(self)\n",
      " |      Creates a function that executes one step of inference.\n",
      " |      \n",
      " |      This method can be overridden to support custom inference logic.\n",
      " |      This method is called by `Model.predict` and `Model.predict_on_batch`.\n",
      " |      \n",
      " |      Typically, this method directly controls `tf.function` and\n",
      " |      `tf.distribute.Strategy` settings, and delegates the actual evaluation\n",
      " |      logic to `Model.predict_step`.\n",
      " |      \n",
      " |      This function is cached the first time `Model.predict` or\n",
      " |      `Model.predict_on_batch` is called. The cache is cleared whenever\n",
      " |      `Model.compile` is called.\n",
      " |      \n",
      " |      Returns:\n",
      " |        Function. The function created by this method should accept a\n",
      " |        `tf.data.Iterator`, and return the outputs of the `Model`.\n",
      " |  \n",
      " |  make_test_function(self)\n",
      " |      Creates a function that executes one step of evaluation.\n",
      " |      \n",
      " |      This method can be overridden to support custom evaluation logic.\n",
      " |      This method is called by `Model.evaluate` and `Model.test_on_batch`.\n",
      " |      \n",
      " |      Typically, this method directly controls `tf.function` and\n",
      " |      `tf.distribute.Strategy` settings, and delegates the actual evaluation\n",
      " |      logic to `Model.test_step`.\n",
      " |      \n",
      " |      This function is cached the first time `Model.evaluate` or\n",
      " |      `Model.test_on_batch` is called. The cache is cleared whenever\n",
      " |      `Model.compile` is called.\n",
      " |      \n",
      " |      Returns:\n",
      " |        Function. The function created by this method should accept a\n",
      " |        `tf.data.Iterator`, and return a `dict` containing values that will\n",
      " |        be passed to `tf.keras.Callbacks.on_test_batch_end`.\n",
      " |  \n",
      " |  make_train_function(self)\n",
      " |      Creates a function that executes one step of training.\n",
      " |      \n",
      " |      This method can be overridden to support custom training logic.\n",
      " |      This method is called by `Model.fit` and `Model.train_on_batch`.\n",
      " |      \n",
      " |      Typically, this method directly controls `tf.function` and\n",
      " |      `tf.distribute.Strategy` settings, and delegates the actual training\n",
      " |      logic to `Model.train_step`.\n",
      " |      \n",
      " |      This function is cached the first time `Model.fit` or\n",
      " |      `Model.train_on_batch` is called. The cache is cleared whenever\n",
      " |      `Model.compile` is called.\n",
      " |      \n",
      " |      Returns:\n",
      " |        Function. The function created by this method should accept a\n",
      " |        `tf.data.Iterator`, and return a `dict` containing values that will\n",
      " |        be passed to `tf.keras.Callbacks.on_train_batch_end`, such as\n",
      " |        `{'loss': 0.2, 'accuracy': 0.7}`.\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. This method is designed for performance in\n",
      " |      large scale inputs. For small amount of inputs that fit in one batch,\n",
      " |      directly using `__call__` is recommended for faster execution, e.g.,\n",
      " |      `model(x)`, or `model(x, training=False)` if you have layers such as\n",
      " |      `tf.keras.layers.BatchNormalization` that behaves differently during\n",
      " |      inference.\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",
      " |            A more detailed description of unpacking behavior for iterator types\n",
      " |            (Dataset, generator, Sequence) is given in the `Unpacking behavior\n",
      " |            for iterator-like inputs` section of `Model.fit`.\n",
      " |          batch_size: Integer or `None`.\n",
      " |              Number of samples per batch.\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 dataset, generators, or `keras.utils.Sequence` instances\n",
      " |              (since they generate 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",
      " |      See the discussion of `Unpacking behavior for iterator-like inputs` for\n",
      " |      `Model.fit`. Note that Model.predict uses the same interpretation rules as\n",
      " |      `Model.fit` and `Model.evaluate`, so inputs must be unambiguous for all\n",
      " |      three methods.\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. (deprecated)\n",
      " |      \n",
      " |      Warning: THIS FUNCTION IS DEPRECATED. It will be removed in a future version.\n",
      " |      Instructions for updating:\n",
      " |      Please use Model.predict, which supports generators.\n",
      " |      \n",
      " |      DEPRECATED:\n",
      " |        `Model.predict` now supports generators, so there is no longer any need\n",
      " |        to use this endpoint.\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: - A Numpy array (or array-like), or a list\n",
      " |            of arrays (in case the model has multiple inputs). - A TensorFlow\n",
      " |            tensor, or a list of tensors (in case the model has multiple inputs).\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",
      " |  predict_step(self, data)\n",
      " |      The logic for one inference step.\n",
      " |      \n",
      " |      This method can be overridden to support custom inference logic.\n",
      " |      This method is called by `Model.make_predict_function`.\n",
      " |      \n",
      " |      This method should contain the mathemetical logic for one step of inference.\n",
      " |      This typically includes the forward pass.\n",
      " |      \n",
      " |      Configuration details for *how* this logic is run (e.g. `tf.function` and\n",
      " |      `tf.distribute.Strategy` settings), should be left to\n",
      " |      `Model.make_predict_function`, which can also be overridden.\n",
      " |      \n",
      " |      Arguments:\n",
      " |        data: A nested structure of `Tensor`s.\n",
      " |      \n",
      " |      Returns:\n",
      " |        The result of one inference step, typically the output of calling the\n",
      " |        `Model` on data.\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, return_dict=False)\n",
      " |      Test the model on a single batch of samples.\n",
      " |      \n",
      " |      Arguments:\n",
      " |          x: Input data. It could be: - A Numpy array (or array-like), or a list\n",
      " |            of arrays (in case the model has multiple inputs). - A TensorFlow\n",
      " |            tensor, or a list of tensors (in case the model has multiple inputs).\n",
      " |            - A dict mapping input names to the corresponding array/tensors, if\n",
      " |            the model has named inputs.\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).\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().\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",
      " |          return_dict: If `True`, loss and metric results are returned as a dict,\n",
      " |            with each key being the name of the metric. If `False`, they are\n",
      " |            returned as a list.\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",
      " |  test_step(self, data)\n",
      " |      The logic for one evaluation step.\n",
      " |      \n",
      " |      This method can be overridden to support custom evaluation logic.\n",
      " |      This method is called by `Model.make_test_function`.\n",
      " |      \n",
      " |      This function should contain the mathemetical logic for one step of\n",
      " |      evaluation.\n",
      " |      This typically includes the forward pass, loss calculation, and metrics\n",
      " |      updates.\n",
      " |      \n",
      " |      Configuration details for *how* this logic is run (e.g. `tf.function` and\n",
      " |      `tf.distribute.Strategy` settings), should be left to\n",
      " |      `Model.make_test_function`, which can also be overridden.\n",
      " |      \n",
      " |      Arguments:\n",
      " |        data: A nested structure of `Tensor`s.\n",
      " |      \n",
      " |      Returns:\n",
      " |        A `dict` containing values that will be passed to\n",
      " |        `tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the\n",
      " |        values of the `Model`'s metrics are returned.\n",
      " |  \n",
      " |  train_on_batch(self, x, y=None, sample_weight=None, class_weight=None, reset_metrics=True, return_dict=False)\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",
      " |          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).\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().\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",
      " |          return_dict: If `True`, loss and metric results are returned as a dict,\n",
      " |            with each key being the name of the metric. If `False`, they are\n",
      " |            returned as a list.\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",
      " |  train_step(self, data)\n",
      " |      The logic for one training step.\n",
      " |      \n",
      " |      This method can be overridden to support custom training logic.\n",
      " |      This method is called by `Model.make_train_function`.\n",
      " |      \n",
      " |      This method should contain the mathemetical logic for one step of training.\n",
      " |      This typically includes the forward pass, loss calculation, backpropagation,\n",
      " |      and metric updates.\n",
      " |      \n",
      " |      Configuration details for *how* this logic is run (e.g. `tf.function` and\n",
      " |      `tf.distribute.Strategy` settings), should be left to\n",
      " |      `Model.make_train_function`, which can also be overridden.\n",
      " |      \n",
      " |      Arguments:\n",
      " |        data: A nested structure of `Tensor`s.\n",
      " |      \n",
      " |      Returns:\n",
      " |        A `dict` containing values that will be passed to\n",
      " |        `tf.keras.callbacks.CallbackList.on_train_batch_end`. Typically, the\n",
      " |        values of the `Model`'s metrics are returned. Example:\n",
      " |        `{'loss': 0.2, 'accuracy': 0.7}`.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from tensorflow.python.keras.engine.training.Model:\n",
      " |  \n",
      " |  distribute_strategy\n",
      " |      The `tf.distribute.Strategy` this model was created under.\n",
      " |  \n",
      " |  metrics\n",
      " |      Returns the model's metrics added using `compile`, `add_metric` APIs.\n",
      " |      \n",
      " |      Note: `metrics` are available only after a `keras.Model` has been\n",
      " |      trained/evaluated on actual data.\n",
      " |      \n",
      " |      Examples:\n",
      " |      \n",
      " |      >>> inputs = tf.keras.layers.Input(shape=(3,))\n",
      " |      >>> outputs = tf.keras.layers.Dense(2)(inputs)\n",
      " |      >>> model = tf.keras.models.Model(inputs=inputs, outputs=outputs)\n",
      " |      >>> model.compile(optimizer=\"Adam\", loss=\"mse\", metrics=[\"mae\"])\n",
      " |      >>> [m.name for m in model.metrics]\n",
      " |      []\n",
      " |      \n",
      " |      >>> x = np.random.random((2, 3))\n",
      " |      >>> y = np.random.randint(0, 2, (2, 2))\n",
      " |      >>> _ = model.fit(x, y, verbose=0)\n",
      " |      >>> [m.name for m in model.metrics]\n",
      " |      ['loss', 'mae']\n",
      " |      \n",
      " |      >>> inputs = tf.keras.layers.Input(shape=(3,))\n",
      " |      >>> d = tf.keras.layers.Dense(2, name='out')\n",
      " |      >>> output_1 = d(inputs)\n",
      " |      >>> output_2 = d(inputs)\n",
      " |      >>> model = tf.keras.models.Model(\n",
      " |      ...    inputs=inputs, outputs=[output_1, output_2])\n",
      " |      >>> model.add_metric(\n",
      " |      ...    tf.reduce_sum(output_2), name='mean', aggregation='mean')\n",
      " |      >>> model.compile(optimizer=\"Adam\", loss=\"mse\", metrics=[\"mae\", \"acc\"])\n",
      " |      >>> _ = model.fit(x, (y, y), verbose=0)\n",
      " |      >>> [m.name for m in model.metrics]\n",
      " |      ['loss', 'out_loss', 'out_1_loss', 'out_mae', 'out_acc', 'out_1_mae',\n",
      " |      'out_1_acc', 'mean']\n",
      " |  \n",
      " |  metrics_names\n",
      " |      Returns the model's display labels for all outputs.\n",
      " |      \n",
      " |      Note: `metrics_names` are available only after a `keras.Model` has been\n",
      " |      trained/evaluated on actual data.\n",
      " |      \n",
      " |      Examples:\n",
      " |      \n",
      " |      >>> inputs = tf.keras.layers.Input(shape=(3,))\n",
      " |      >>> outputs = tf.keras.layers.Dense(2)(inputs)\n",
      " |      >>> model = tf.keras.models.Model(inputs=inputs, outputs=outputs)\n",
      " |      >>> model.compile(optimizer=\"Adam\", loss=\"mse\", metrics=[\"mae\"])\n",
      " |      >>> model.metrics_names\n",
      " |      []\n",
      " |      \n",
      " |      >>> x = np.random.random((2, 3))\n",
      " |      >>> y = np.random.randint(0, 2, (2, 2))\n",
      " |      >>> _ = model.fit(x, y, verbose=0)\n",
      " |      >>> model.metrics_names\n",
      " |      ['loss', 'mae']\n",
      " |      \n",
      " |      >>> inputs = tf.keras.layers.Input(shape=(3,))\n",
      " |      >>> d = tf.keras.layers.Dense(2, name='out')\n",
      " |      >>> output_1 = d(inputs)\n",
      " |      >>> output_2 = d(inputs)\n",
      " |      >>> model = tf.keras.models.Model(\n",
      " |      ...    inputs=inputs, outputs=[output_1, output_2])\n",
      " |      >>> model.compile(optimizer=\"Adam\", loss=\"mse\", metrics=[\"mae\", \"acc\"])\n",
      " |      >>> _ = model.fit(x, (y, y), verbose=0)\n",
      " |      >>> model.metrics_names\n",
      " |      ['loss', 'out_loss', 'out_1_loss', 'out_mae', 'out_acc', 'out_1_mae',\n",
      " |      'out_1_acc']\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",
      " |  ----------------------------------------------------------------------\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` is a compiled model ready to be used\n",
      " |      (unless the saved model was never compiled in the first place).\n",
      " |      \n",
      " |      Models built with the Sequential and Functional API can be saved to both the\n",
      " |      HDF5 and SavedModel formats. Subclassed models can only be saved with the\n",
      " |      SavedModel format.\n",
      " |      \n",
      " |      Note that the model weights may have different scoped names after being\n",
      " |      loaded. Scoped names include the model/layer names, such as\n",
      " |      \"dense_1/kernel:0\"`. It is recommended that you use the layer properties to\n",
      " |       access specific variables, e.g. `model.get_layer(\"dense_1\").kernel`.\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. Defaults to 'tf' in TF 2.X, and\n",
      " |              'h5' in TF 1.X.\n",
      " |          signatures: Signatures to save with the SavedModel. Applicable to the\n",
      " |              'tf' 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/guide/checkpoint) 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",
      " |      List of all non-trainable weights tracked by this layer.\n",
      " |      \n",
      " |      Non-trainable weights are *not* updated during training. They are expected\n",
      " |      to be updated manually in `call()`.\n",
      " |      \n",
      " |      Returns:\n",
      " |        A list of non-trainable variables.\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",
      " |      List of all trainable weights tracked by this layer.\n",
      " |      \n",
      " |      Trainable weights are updated via gradient descent during training.\n",
      " |      \n",
      " |      Returns:\n",
      " |        A list of trainable variables.\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, *args, **kwargs)\n",
      " |      Wraps `call`, applying pre- and post-processing steps.\n",
      " |      \n",
      " |      Arguments:\n",
      " |        *args: Positional arguments to be passed to `self.call`.\n",
      " |        **kwargs: 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",
      " |        RuntimeError: if `super().__init__()` was not called in the constructor.\n",
      " |  \n",
      " |  __delattr__(self, name)\n",
      " |      Implement delattr(self, name).\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __setstate__(self, state)\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",
      " |      # Activity 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`,\n",
      " |          `collections`, `experimental_autocast` and `caching_device`.\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",
      " |      The weights of a layer represent the state of the layer. This function\n",
      " |      sets the weight values from numpy arrays. The weight values should be\n",
      " |      passed in the order they are created by the layer. Note that the layer's\n",
      " |      weights must be instantiated before calling this function by calling\n",
      " |      the layer.\n",
      " |      \n",
      " |      For example, a Dense layer returns a list of two values-- per-output\n",
      " |      weights and the bias value. These can be used to set the weights of another\n",
      " |      Dense layer:\n",
      " |      \n",
      " |      >>> a = tf.keras.layers.Dense(1,\n",
      " |      ...   kernel_initializer=tf.constant_initializer(1.))\n",
      " |      >>> a_out = a(tf.convert_to_tensor([[1., 2., 3.]]))\n",
      " |      >>> a.get_weights()\n",
      " |      [array([[1.],\n",
      " |             [1.],\n",
      " |             [1.]], dtype=float32), array([0.], dtype=float32)]\n",
      " |      >>> b = tf.keras.layers.Dense(1,\n",
      " |      ...   kernel_initializer=tf.constant_initializer(2.))\n",
      " |      >>> b_out = b(tf.convert_to_tensor([[10., 20., 30.]]))\n",
      " |      >>> b.get_weights()\n",
      " |      [array([[2.],\n",
      " |             [2.],\n",
      " |             [2.]], dtype=float32), array([0.], dtype=float32)]\n",
      " |      >>> b.set_weights(a.get_weights())\n",
      " |      >>> b.get_weights()\n",
      " |      [array([[1.],\n",
      " |             [1.],\n",
      " |             [1.]], dtype=float32), array([0.], dtype=float32)]\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",
      " |      Dtype used by the weights of the layer, set in the constructor.\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",
      " |      Name of the layer (string), set in the constructor.\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 trainable variables owned by this module and its 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",
      " |      >>> 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], 3]))\n",
      " |      ...     return tf.matmul(x, self.w)\n",
      " |      \n",
      " |      Using the above module would produce `tf.Variable`s and `tf.Tensor`s whose\n",
      " |      names included the module name:\n",
      " |      \n",
      " |      >>> mod = MyModule()\n",
      " |      >>> mod(tf.ones([1, 2]))\n",
      " |      <tf.Tensor: shape=(1, 3), dtype=float32, numpy=..., dtype=float32)>\n",
      " |      >>> mod.w\n",
      " |      <tf.Variable 'my_module/Variable:0' shape=(2, 3) dtype=float32,\n",
      " |      numpy=..., dtype=float32)>\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",
      " |      >>> a = tf.Module()\n",
      " |      >>> b = tf.Module()\n",
      " |      >>> c = tf.Module()\n",
      " |      >>> a.b = b\n",
      " |      >>> b.c = c\n",
      " |      >>> list(a.submodules) == [b, c]\n",
      " |      True\n",
      " |      >>> list(b.submodules) == [c]\n",
      " |      True\n",
      " |      >>> list(c.submodules) == []\n",
      " |      True\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",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from tensorflow.python.keras.utils.version_utils.LayerVersionSelector:\n",
      " |  \n",
      " |  __new__(cls, *args, **kwargs)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Sequential)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Activation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "tags": [
     "outputPrepend"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Dense in module tensorflow.python.keras.layers.core:\n",
      "\n",
      "class Dense(tensorflow.python.keras.engine.base_layer.Layer)\n",
      " |  Dense(*args, **kwargs)\n",
      " |  \n",
      " |  Just your regular densely-connected NN layer.\n",
      " |  \n",
      " |  `Dense` implements the operation:\n",
      " |  `output = activation(dot(input, kernel) + bias)`\n",
      " |  where `activation` is the element-wise activation function\n",
      " |  passed as the `activation` argument, `kernel` is a weights matrix\n",
      " |  created by the layer, and `bias` is a bias vector created by the layer\n",
      " |  (only applicable if `use_bias` is `True`).\n",
      " |  \n",
      " |  Note: If the input to the layer has a rank greater than 2, then `Dense`\n",
      " |  computes the dot product between the `inputs` and the `kernel` along the\n",
      " |  last axis of the `inputs` and axis 1 of the `kernel` (using `tf.tensordot`).\n",
      " |  For example, if input has dimensions `(batch_size, d0, d1)`,\n",
      " |  then we create a `kernel` with shape `(d1, units)`, and the `kernel` operates\n",
      " |  along axis 2 of the `input`, on every sub-tensor of shape `(1, 1, d1)`\n",
      " |  (there are `batch_size * d0` such sub-tensors).\n",
      " |  The output in this case will have shape `(batch_size, d0, units)`.\n",
      " |  \n",
      " |  Besides, layer attributes cannot be modified after the layer has been called\n",
      " |  once (except the `trainable` attribute).\n",
      " |  \n",
      " |  Example:\n",
      " |  \n",
      " |  ```python\n",
      " |  # as first layer in a sequential model:\n",
      " |  model = Sequential()\n",
      " |  model.add(Dense(32, input_shape=(16,)))\n",
      " |  # now the model will take as input arrays of shape (*, 16)\n",
      " |  # and output arrays of shape (*, 32)\n",
      " |  \n",
      " |  # after the first layer, you don't need to specify\n",
      " |  # the size of the input anymore:\n",
      " |  model.add(Dense(32))\n",
      " |  ```\n",
      " |  \n",
      " |  Arguments:\n",
      " |    units: Positive integer, dimensionality of the output space.\n",
      " |    activation: Activation function to use.\n",
      " |      If you don't specify anything, no activation is applied\n",
      " |      (ie. \"linear\" activation: `a(x) = x`).\n",
      " |    use_bias: Boolean, whether the layer uses a bias vector.\n",
      " |    kernel_initializer: Initializer for the `kernel` weights matrix.\n",
      " |    bias_initializer: Initializer for the bias vector.\n",
      " |    kernel_regularizer: Regularizer function applied to\n",
      " |      the `kernel` weights matrix.\n",
      " |    bias_regularizer: Regularizer function applied to the bias vector.\n",
      " |    activity_regularizer: Regularizer function applied to\n",
      " |      the output of the layer (its \"activation\")..\n",
      " |    kernel_constraint: Constraint function applied to\n",
      " |      the `kernel` weights matrix.\n",
      " |    bias_constraint: Constraint function applied to the bias vector.\n",
      " |  \n",
      " |  Input shape:\n",
      " |    N-D tensor with shape: `(batch_size, ..., input_dim)`.\n",
      " |    The most common situation would be\n",
      " |    a 2D input with shape `(batch_size, input_dim)`.\n",
      " |  \n",
      " |  Output shape:\n",
      " |    N-D tensor with shape: `(batch_size, ..., units)`.\n",
      " |    For instance, for a 2D input with shape `(batch_size, input_dim)`,\n",
      " |    the output would have shape `(batch_size, units)`.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Dense\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",
      " |      tensorflow.python.keras.utils.version_utils.LayerVersionSelector\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs)\n",
      " |  \n",
      " |  build(self, input_shape)\n",
      " |      Creates the variables of the layer (optional, for subclass implementers).\n",
      " |      \n",
      " |      This is a method that implementers of subclasses of `Layer` or `Model`\n",
      " |      can override if they need a state-creation step in-between\n",
      " |      layer instantiation and layer call.\n",
      " |      \n",
      " |      This is typically used to create the weights of `Layer` subclasses.\n",
      " |      \n",
      " |      Arguments:\n",
      " |        input_shape: Instance of `TensorShape`, or list of instances of\n",
      " |          `TensorShape` if the layer expects a list of inputs\n",
      " |          (one instance per input).\n",
      " |  \n",
      " |  call(self, inputs)\n",
      " |      This is where the layer's logic lives.\n",
      " |      \n",
      " |      Arguments:\n",
      " |          inputs: Input tensor, or list/tuple of input tensors.\n",
      " |          **kwargs: Additional keyword arguments.\n",
      " |      \n",
      " |      Returns:\n",
      " |          A tensor or list/tuple of tensors.\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",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from tensorflow.python.keras.engine.base_layer.Layer:\n",
      " |  \n",
      " |  __call__(self, *args, **kwargs)\n",
      " |      Wraps `call`, applying pre- and post-processing steps.\n",
      " |      \n",
      " |      Arguments:\n",
      " |        *args: Positional arguments to be passed to `self.call`.\n",
      " |        **kwargs: 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",
      " |        RuntimeError: if `super().__init__()` was not called in the constructor.\n",
      " |  \n",
      " |  __delattr__(self, name)\n",
      " |      Implement delattr(self, name).\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __setattr__(self, name, value)\n",
      " |      Support self.foo = trackable syntax.\n",
      " |  \n",
      " |  __setstate__(self, state)\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",
      " |      # Activity 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`,\n",
      " |          `collections`, `experimental_autocast` and `caching_device`.\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_mask(self, inputs, mask=None)\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_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",
      " |  get_weights(self)\n",
      " |      Returns the current weights of the layer.\n",
      " |      \n",
      " |      The weights of a layer represent the state of the layer. This function\n",
      " |      returns both trainable and non-trainable weight values associated with this\n",
      " |      layer as a list of Numpy arrays, which can in turn be used to load state\n",
      " |      into similarly parameterized layers.\n",
      " |      \n",
      " |      For example, a Dense layer returns a list of two values-- per-output\n",
      " |      weights and the bias value. These can be used to set the weights of another\n",
      " |      Dense layer:\n",
      " |      \n",
      " |      >>> a = tf.keras.layers.Dense(1,\n",
      " |      ...   kernel_initializer=tf.constant_initializer(1.))\n",
      " |      >>> a_out = a(tf.convert_to_tensor([[1., 2., 3.]]))\n",
      " |      >>> a.get_weights()\n",
      " |      [array([[1.],\n",
      " |             [1.],\n",
      " |             [1.]], dtype=float32), array([0.], dtype=float32)]\n",
      " |      >>> b = tf.keras.layers.Dense(1,\n",
      " |      ...   kernel_initializer=tf.constant_initializer(2.))\n",
      " |      >>> b_out = b(tf.convert_to_tensor([[10., 20., 30.]]))\n",
      " |      >>> b.get_weights()\n",
      " |      [array([[2.],\n",
      " |             [2.],\n",
      " |             [2.]], dtype=float32), array([0.], dtype=float32)]\n",
      " |      >>> b.set_weights(a.get_weights())\n",
      " |      >>> b.get_weights()\n",
      " |      [array([[1.],\n",
      " |             [1.],\n",
      " |             [1.]], dtype=float32), array([0.], dtype=float32)]\n",
      " |      \n",
      " |      Returns:\n",
      " |          Weights values as a list of numpy arrays.\n",
      " |  \n",
      " |  set_weights(self, weights)\n",
      " |      Sets the weights of the layer, from Numpy arrays.\n",
      " |      \n",
      " |      The weights of a layer represent the state of the layer. This function\n",
      " |      sets the weight values from numpy arrays. The weight values should be\n",
      " |      passed in the order they are created by the layer. Note that the layer's\n",
      " |      weights must be instantiated before calling this function by calling\n",
      " |      the layer.\n",
      " |      \n",
      " |      For example, a Dense layer returns a list of two values-- per-output\n",
      " |      weights and the bias value. These can be used to set the weights of another\n",
      " |      Dense layer:\n",
      " |      \n",
      " |      >>> a = tf.keras.layers.Dense(1,\n",
      " |      ...   kernel_initializer=tf.constant_initializer(1.))\n",
      " |      >>> a_out = a(tf.convert_to_tensor([[1., 2., 3.]]))\n",
      " |      >>> a.get_weights()\n",
      " |      [array([[1.],\n",
      " |             [1.],\n",
      " |             [1.]], dtype=float32), array([0.], dtype=float32)]\n",
      " |      >>> b = tf.keras.layers.Dense(1,\n",
      " |      ...   kernel_initializer=tf.constant_initializer(2.))\n",
      " |      >>> b_out = b(tf.convert_to_tensor([[10., 20., 30.]]))\n",
      " |      >>> b.get_weights()\n",
      " |      [array([[2.],\n",
      " |             [2.],\n",
      " |             [2.]], dtype=float32), array([0.], dtype=float32)]\n",
      " |      >>> b.set_weights(a.get_weights())\n",
      " |      >>> b.get_weights()\n",
      " |      [array([[1.],\n",
      " |             [1.],\n",
      " |             [1.]], dtype=float32), array([0.], dtype=float32)]\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",
      " |  Class methods inherited from tensorflow.python.keras.engine.base_layer.Layer:\n",
      " |  \n",
      " |  from_config(config) from builtins.type\n",
      " |      Creates a layer from its config.\n",
      " |      \n",
      " |      This method is the reverse of `get_config`,\n",
      " |      capable of instantiating the same layer from the config\n",
      " |      dictionary. It does not handle layer connectivity\n",
      " |      (handled by Network), nor weights (handled by `set_weights`).\n",
      " |      \n",
      " |      Arguments:\n",
      " |          config: A Python dictionary, typically the\n",
      " |              output of get_config.\n",
      " |      \n",
      " |      Returns:\n",
      " |          A layer instance.\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",
      " |      Dtype used by the weights of the layer, set in the constructor.\n",
      " |  \n",
      " |  dynamic\n",
      " |      Whether the layer is dynamic (eager-only); set in the constructor.\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",
      " |  input_spec\n",
      " |      `InputSpec` instance(s) describing the input format for this layer.\n",
      " |      \n",
      " |      When you create a layer subclass, you can set `self.input_spec` to enable\n",
      " |      the layer to run input compatibility checks when it is called.\n",
      " |      Consider a `Conv2D` layer: it can only be called on a single input tensor\n",
      " |      of rank 4. As such, you can set, in `__init__()`:\n",
      " |      \n",
      " |      ```python\n",
      " |      self.input_spec = tf.keras.layers.InputSpec(ndim=4)\n",
      " |      ```\n",
      " |      \n",
      " |      Now, if you try to call the layer on an input that isn't rank 4\n",
      " |      (for instance, an input of shape `(2,)`, it will raise a nicely-formatted\n",
      " |      error:\n",
      " |      \n",
      " |      ```\n",
      " |      ValueError: Input 0 of layer conv2d is incompatible with the layer:\n",
      " |      expected ndim=4, found ndim=1. Full shape received: [2]\n",
      " |      ```\n",
      " |      \n",
      " |      Input checks that can be specified via `input_spec` include:\n",
      " |      - Structure (e.g. a single input, a list of 2 inputs, etc)\n",
      " |      - Shape\n",
      " |      - Rank (ndim)\n",
      " |      - Dtype\n",
      " |      \n",
      " |      For more information, see `tf.keras.layers.InputSpec`.\n",
      " |      \n",
      " |      Returns:\n",
      " |        A `tf.keras.layers.InputSpec` instance, or nested structure thereof.\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",
      " |  metrics\n",
      " |      List of `tf.keras.metrics.Metric` instances tracked by the layer.\n",
      " |  \n",
      " |  name\n",
      " |      Name of the layer (string), set in the constructor.\n",
      " |  \n",
      " |  non_trainable_variables\n",
      " |  \n",
      " |  non_trainable_weights\n",
      " |      List of all non-trainable weights tracked by this layer.\n",
      " |      \n",
      " |      Non-trainable weights are *not* updated during training. They are expected\n",
      " |      to be updated manually in `call()`.\n",
      " |      \n",
      " |      Returns:\n",
      " |        A list of 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",
      " |  stateful\n",
      " |  \n",
      " |  trainable\n",
      " |  \n",
      " |  trainable_variables\n",
      " |      Sequence of trainable variables owned by this module and its 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",
      " |  trainable_weights\n",
      " |      List of all trainable weights tracked by this layer.\n",
      " |      \n",
      " |      Trainable weights are updated via gradient descent during training.\n",
      " |      \n",
      " |      Returns:\n",
      " |        A list of trainable variables.\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",
      " |  weights\n",
      " |      Returns the list of all layer variables/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",
      " |      >>> 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], 3]))\n",
      " |      ...     return tf.matmul(x, self.w)\n",
      " |      \n",
      " |      Using the above module would produce `tf.Variable`s and `tf.Tensor`s whose\n",
      " |      names included the module name:\n",
      " |      \n",
      " |      >>> mod = MyModule()\n",
      " |      >>> mod(tf.ones([1, 2]))\n",
      " |      <tf.Tensor: shape=(1, 3), dtype=float32, numpy=..., dtype=float32)>\n",
      " |      >>> mod.w\n",
      " |      <tf.Variable 'my_module/Variable:0' shape=(2, 3) dtype=float32,\n",
      " |      numpy=..., dtype=float32)>\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",
      " |      >>> a = tf.Module()\n",
      " |      >>> b = tf.Module()\n",
      " |      >>> c = tf.Module()\n",
      " |      >>> a.b = b\n",
      " |      >>> b.c = c\n",
      " |      >>> list(a.submodules) == [b, c]\n",
      " |      True\n",
      " |      >>> list(b.submodules) == [c]\n",
      " |      True\n",
      " |      >>> list(c.submodules) == []\n",
      " |      True\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",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from tensorflow.python.keras.utils.version_utils.LayerVersionSelector:\n",
      " |  \n",
      " |  __new__(cls, *args, **kwargs)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Dense)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model - as a list of layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Can be created like this\n",
    "\n",
    "model = Sequential([\n",
    "    Dense(4,activation='relu'),\n",
    "    Dense(2,activation='relu'),\n",
    "    Dense(1),\n",
    "])\n",
    "\n",
    "# But preferably like this because it is easier to try\n",
    "# different layers.\n",
    "\n",
    "model = Sequential()\n",
    "\n",
    "model.add(Dense(4,activation='relu'))\n",
    "model.add(Dense(2,activation='relu'))\n",
    "model.add(Dense(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model - adding in layers one by one"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's go ahead and build a simple model and then compile it by defining our solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "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')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": {},
   "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",
   "execution_count": 24,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 256845.0312\n",
      "Epoch 2/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 256514.1094\n",
      "Epoch 3/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 256310.0156\n",
      "Epoch 4/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 256116.9375\n",
      "Epoch 5/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 255885.3281\n",
      "Epoch 6/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 255616.0156\n",
      "Epoch 7/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 255304.2812\n",
      "Epoch 8/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 254949.8906\n",
      "Epoch 9/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 254550.7812\n",
      "Epoch 10/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 254099.0469\n",
      "Epoch 11/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 253587.2188\n",
      "Epoch 12/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 253018.3281\n",
      "Epoch 13/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 252390.4531\n",
      "Epoch 14/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 251691.2031\n",
      "Epoch 15/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 250923.7969\n",
      "Epoch 16/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 250086.1250\n",
      "Epoch 17/250\n",
      "22/22 [==============================] - 0s 9ms/step - loss: 249164.4531\n",
      "Epoch 18/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 248156.4531\n",
      "Epoch 19/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 247068.4844\n",
      "Epoch 20/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 245884.4844\n",
      "Epoch 21/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 244603.6562\n",
      "Epoch 22/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 243216.2344\n",
      "Epoch 23/250\n",
      "22/22 [==============================] - 0s 9ms/step - loss: 241724.5938\n",
      "Epoch 24/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 240127.2500\n",
      "Epoch 25/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 238413.0781\n",
      "Epoch 26/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 236576.3438\n",
      "Epoch 27/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 234619.6562\n",
      "Epoch 28/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 232534.3750\n",
      "Epoch 29/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 230302.9219\n",
      "Epoch 30/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 227958.2656\n",
      "Epoch 31/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 225469.3750\n",
      "Epoch 32/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 222810.3594\n",
      "Epoch 33/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 220031.2500\n",
      "Epoch 34/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 217069.8906\n",
      "Epoch 35/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 213979.3906\n",
      "Epoch 36/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 210733.3750\n",
      "Epoch 37/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 207310.9062\n",
      "Epoch 38/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 203735.0469\n",
      "Epoch 39/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 200011.2656\n",
      "Epoch 40/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 196108.4531\n",
      "Epoch 41/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 192037.1719\n",
      "Epoch 42/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 187815.1250\n",
      "Epoch 43/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 183412.4062\n",
      "Epoch 44/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 178847.0156\n",
      "Epoch 45/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 174135.2188\n",
      "Epoch 46/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 169253.5625\n",
      "Epoch 47/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 164172.1094\n",
      "Epoch 48/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 158983.2656\n",
      "Epoch 49/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 153628.7969\n",
      "Epoch 50/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 148162.2344\n",
      "Epoch 51/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 142513.0625\n",
      "Epoch 52/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 136747.7500\n",
      "Epoch 53/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 130882.9062\n",
      "Epoch 54/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 124917.8438\n",
      "Epoch 55/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 118808.8594\n",
      "Epoch 56/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 112629.7578\n",
      "Epoch 57/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 106380.7422\n",
      "Epoch 58/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 100079.2109\n",
      "Epoch 59/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 93745.5391\n",
      "Epoch 60/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 87395.5859\n",
      "Epoch 61/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 81037.9453\n",
      "Epoch 62/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 74699.9141\n",
      "Epoch 63/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 68411.8828\n",
      "Epoch 64/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 62227.0391\n",
      "Epoch 65/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 56137.2930\n",
      "Epoch 66/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 50145.6289\n",
      "Epoch 67/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 44352.1445\n",
      "Epoch 68/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 38777.5781\n",
      "Epoch 69/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 33443.8516\n",
      "Epoch 70/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 28326.7285\n",
      "Epoch 71/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 23599.9219\n",
      "Epoch 72/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 19201.4395\n",
      "Epoch 73/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 15237.2500\n",
      "Epoch 74/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 11697.8330\n",
      "Epoch 75/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 8677.8096\n",
      "Epoch 76/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 6213.9473\n",
      "Epoch 77/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 4318.9360\n",
      "Epoch 78/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 3014.3096\n",
      "Epoch 79/250\n",
      "22/22 [==============================] - 0s 12ms/step - loss: 2284.2756\n",
      "Epoch 80/250\n",
      "22/22 [==============================] - 0s 10ms/step - loss: 2024.6827\n",
      "Epoch 81/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 1959.5354\n",
      "Epoch 82/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 1923.4131\n",
      "Epoch 83/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 1887.4479\n",
      "Epoch 84/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 1845.6743\n",
      "Epoch 85/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 1810.3519\n",
      "Epoch 86/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 1769.8755\n",
      "Epoch 87/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 1736.7917\n",
      "Epoch 88/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 1701.9630\n",
      "Epoch 89/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 1670.1481\n",
      "Epoch 90/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 1632.6520\n",
      "Epoch 91/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 1591.6825\n",
      "Epoch 92/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 1562.3143\n",
      "Epoch 93/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 1524.6586\n",
      "Epoch 94/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 1490.3920\n",
      "Epoch 95/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 1456.8545\n",
      "Epoch 96/250\n",
      "22/22 [==============================] - 0s 9ms/step - loss: 1424.1415\n",
      "Epoch 97/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 1395.8489\n",
      "Epoch 98/250\n",
      "22/22 [==============================] - 0s 9ms/step - loss: 1362.1102\n",
      "Epoch 99/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 1330.3007\n",
      "Epoch 100/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 1301.6188\n",
      "Epoch 101/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 1269.6569\n",
      "Epoch 102/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 1238.5497\n",
      "Epoch 103/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 1207.2321\n",
      "Epoch 104/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 1180.0388\n",
      "Epoch 105/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 1146.1635\n",
      "Epoch 106/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 1118.8837\n",
      "Epoch 107/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 1089.5482\n",
      "Epoch 108/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 1056.9664\n",
      "Epoch 109/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 1024.8618\n",
      "Epoch 110/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 1000.9720\n",
      "Epoch 111/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 972.8684\n",
      "Epoch 112/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 943.7789\n",
      "Epoch 113/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 912.6682\n",
      "Epoch 114/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 885.4827\n",
      "Epoch 115/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 855.2683\n",
      "Epoch 116/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 826.5312\n",
      "Epoch 117/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 800.5867\n",
      "Epoch 118/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 773.1911\n",
      "Epoch 119/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 747.3419\n",
      "Epoch 120/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 722.2285\n",
      "Epoch 121/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 698.5972\n",
      "Epoch 122/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 675.1128\n",
      "Epoch 123/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 652.2213\n",
      "Epoch 124/250\n",
      "22/22 [==============================] - 0s 12ms/step - loss: 628.6027\n",
      "Epoch 125/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 608.8750\n",
      "Epoch 126/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 586.8226\n",
      "Epoch 127/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 566.1901\n",
      "Epoch 128/250\n",
      "22/22 [==============================] - 0s 10ms/step - loss: 542.4594\n",
      "Epoch 129/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 522.0972\n",
      "Epoch 130/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 500.9337\n",
      "Epoch 131/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 478.2222\n",
      "Epoch 132/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 457.9067\n",
      "Epoch 133/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 435.6737\n",
      "Epoch 134/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 417.7666\n",
      "Epoch 135/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 396.8632\n",
      "Epoch 136/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 382.3326\n",
      "Epoch 137/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 364.0923\n",
      "Epoch 138/250\n",
      "22/22 [==============================] - 0s 10ms/step - loss: 347.8849\n",
      "Epoch 139/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 329.7381\n",
      "Epoch 140/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 314.0439\n",
      "Epoch 141/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 299.4961\n",
      "Epoch 142/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 283.4689\n",
      "Epoch 143/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 268.0074\n",
      "Epoch 144/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 253.7633\n",
      "Epoch 145/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 237.5055\n",
      "Epoch 146/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 223.7934\n",
      "Epoch 147/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 210.5050\n",
      "Epoch 148/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 197.0273\n",
      "Epoch 149/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 182.1164\n",
      "Epoch 150/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 171.0878\n",
      "Epoch 151/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 159.6761\n",
      "Epoch 152/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 149.3591\n",
      "Epoch 153/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 139.6421\n",
      "Epoch 154/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 129.8087\n",
      "Epoch 155/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 121.8806\n",
      "Epoch 156/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 113.3187\n",
      "Epoch 157/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 103.9516\n",
      "Epoch 158/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 96.2970\n",
      "Epoch 159/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 88.9748\n",
      "Epoch 160/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 81.8899\n",
      "Epoch 161/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 75.9475\n",
      "Epoch 162/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 69.8025\n",
      "Epoch 163/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 64.8448\n",
      "Epoch 164/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 59.7928\n",
      "Epoch 165/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 55.0910\n",
      "Epoch 166/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 51.0781\n",
      "Epoch 167/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 47.2365\n",
      "Epoch 168/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 44.4394\n",
      "Epoch 169/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 41.4271\n",
      "Epoch 170/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 38.5518\n",
      "Epoch 171/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 35.7976\n",
      "Epoch 172/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 34.0178\n",
      "Epoch 173/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 32.4760\n",
      "Epoch 174/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 31.0441\n",
      "Epoch 175/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 30.1029\n",
      "Epoch 176/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 29.1213\n",
      "Epoch 177/250\n",
      "22/22 [==============================] - 0s 9ms/step - loss: 27.9852\n",
      "Epoch 178/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 27.3414\n",
      "Epoch 179/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 26.9080\n",
      "Epoch 180/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 26.2532\n",
      "Epoch 181/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 26.0339\n",
      "Epoch 182/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 25.5542\n",
      "Epoch 183/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 25.1154\n",
      "Epoch 184/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 25.4063\n",
      "Epoch 185/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 24.9169\n",
      "Epoch 186/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.6952\n",
      "Epoch 187/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 25.3678\n",
      "Epoch 188/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.8115\n",
      "Epoch 189/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 24.3751\n",
      "Epoch 190/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 24.7582\n",
      "Epoch 191/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 24.2823\n",
      "Epoch 192/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 24.6245\n",
      "Epoch 193/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.3522\n",
      "Epoch 194/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.2239\n",
      "Epoch 195/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.3848\n",
      "Epoch 196/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.5583\n",
      "Epoch 197/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.5736\n",
      "Epoch 198/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.2939\n",
      "Epoch 199/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.0173\n",
      "Epoch 200/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.3585\n",
      "Epoch 201/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.5657\n",
      "Epoch 202/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.5237\n",
      "Epoch 203/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 24.0924\n",
      "Epoch 204/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.5138\n",
      "Epoch 205/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 24.2481\n",
      "Epoch 206/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 24.0393\n",
      "Epoch 207/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 24.2537\n",
      "Epoch 208/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 24.2073\n",
      "Epoch 209/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.5988\n",
      "Epoch 210/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 23.9955\n",
      "Epoch 211/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 24.0836\n",
      "Epoch 212/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 24.2762\n",
      "Epoch 213/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 24.2916\n",
      "Epoch 214/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 24.4140\n",
      "Epoch 215/250\n",
      "22/22 [==============================] - 0s 5ms/step - loss: 24.2520\n",
      "Epoch 216/250\n",
      "22/22 [==============================] - 0s 13ms/step - loss: 24.4344\n",
      "Epoch 217/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.4241\n",
      "Epoch 218/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 24.5657\n",
      "Epoch 219/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 24.3161\n",
      "Epoch 220/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 24.3468\n",
      "Epoch 221/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 24.2758\n",
      "Epoch 222/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 23.8661\n",
      "Epoch 223/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 24.3560\n",
      "Epoch 224/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 23.9571\n",
      "Epoch 225/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.2575\n",
      "Epoch 226/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.3594\n",
      "Epoch 227/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.5432\n",
      "Epoch 228/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 23.9416\n",
      "Epoch 229/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.5092\n",
      "Epoch 230/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.2665\n",
      "Epoch 231/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.1729\n",
      "Epoch 232/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.3512\n",
      "Epoch 233/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.3321\n",
      "Epoch 234/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.0981\n",
      "Epoch 235/250\n",
      "22/22 [==============================] - 0s 11ms/step - loss: 24.5603\n",
      "Epoch 236/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 24.2530\n",
      "Epoch 237/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 24.5062\n",
      "Epoch 238/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.4042\n",
      "Epoch 239/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 24.1105\n",
      "Epoch 240/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.3349\n",
      "Epoch 241/250\n",
      "22/22 [==============================] - 0s 7ms/step - loss: 24.4851\n",
      "Epoch 242/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.1976\n",
      "Epoch 243/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.5032\n",
      "Epoch 244/250\n",
      "22/22 [==============================] - 0s 2ms/step - loss: 24.1183\n",
      "Epoch 245/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 23.9738\n",
      "Epoch 246/250\n",
      "22/22 [==============================] - 0s 4ms/step - loss: 24.5734\n",
      "Epoch 247/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.7116\n",
      "Epoch 248/250\n",
      "22/22 [==============================] - 0s 6ms/step - loss: 24.4166\n",
      "Epoch 249/250\n",
      "22/22 [==============================] - 0s 3ms/step - loss: 24.5192\n",
      "Epoch 250/250\n",
      "22/22 [==============================] - 0s 8ms/step - loss: 24.1899\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f611c514a10>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train,y_train,epochs=250)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = model.history.history['loss']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(x=range(len(loss)),y=loss)\n",
    "plt.title(\"Training Loss per Epoch\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['loss']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.metrics_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_score = model.evaluate(X_train,y_train,verbose=0)\n",
    "test_score = model.evaluate(X_test,y_test,verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.46257209777832"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "training_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.703882217407227"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Further Evaluations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_predictions = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[404.41675],\n",
       "       [622.40076],\n",
       "       [591.03235],\n",
       "       [571.1474 ],\n",
       "       [365.78592],\n",
       "       [578.0939 ],\n",
       "       [514.0414 ],\n",
       "       [458.17105],\n",
       "       [548.19446],\n",
       "       [446.59775],\n",
       "       [610.6615 ],\n",
       "       [547.90265],\n",
       "       [418.2098 ],\n",
       "       [407.99142],\n",
       "       [650.07446],\n",
       "       [436.38876],\n",
       "       [507.45776],\n",
       "       [658.7446 ],\n",
       "       [661.39557],\n",
       "       [564.47144],\n",
       "       [333.43887],\n",
       "       [443.9125 ],\n",
       "       [381.67953],\n",
       "       [377.9147 ],\n",
       "       [565.52563],\n",
       "       [609.4669 ],\n",
       "       [531.36255],\n",
       "       [426.96042],\n",
       "       [654.26404],\n",
       "       [413.1999 ],\n",
       "       [441.71982],\n",
       "       [484.158  ],\n",
       "       [437.50162],\n",
       "       [680.63666],\n",
       "       [423.86456],\n",
       "       [416.79636],\n",
       "       [500.94214],\n",
       "       [549.42633],\n",
       "       [508.7299 ],\n",
       "       [394.49197],\n",
       "       [617.45984],\n",
       "       [415.74326],\n",
       "       [603.3351 ],\n",
       "       [445.04117],\n",
       "       [500.99857],\n",
       "       [580.6337 ],\n",
       "       [667.8112 ],\n",
       "       [489.42844],\n",
       "       [317.8141 ],\n",
       "       [484.4566 ],\n",
       "       [516.25635],\n",
       "       [380.94998],\n",
       "       [540.87354],\n",
       "       [407.71848],\n",
       "       [640.3612 ],\n",
       "       [490.0994 ],\n",
       "       [626.79755],\n",
       "       [625.8626 ],\n",
       "       [446.1483 ],\n",
       "       [483.7332 ],\n",
       "       [490.15872],\n",
       "       [473.5853 ],\n",
       "       [681.57983],\n",
       "       [402.41797],\n",
       "       [699.9048 ],\n",
       "       [585.30615],\n",
       "       [582.03436],\n",
       "       [536.8247 ],\n",
       "       [483.60785],\n",
       "       [515.5529 ],\n",
       "       [360.40707],\n",
       "       [539.71954],\n",
       "       [569.556  ],\n",
       "       [527.4396 ],\n",
       "       [452.79208],\n",
       "       [530.1184 ],\n",
       "       [506.21603],\n",
       "       [442.4175 ],\n",
       "       [542.3285 ],\n",
       "       [639.59863],\n",
       "       [465.06497],\n",
       "       [566.1924 ],\n",
       "       [689.5504 ],\n",
       "       [457.79965],\n",
       "       [707.6711 ],\n",
       "       [471.7446 ],\n",
       "       [402.41232],\n",
       "       [584.01434],\n",
       "       [435.84952],\n",
       "       [487.99216],\n",
       "       [615.9103 ],\n",
       "       [438.56592],\n",
       "       [454.39706],\n",
       "       [434.35263],\n",
       "       [505.91815],\n",
       "       [607.3306 ],\n",
       "       [320.86084],\n",
       "       [435.36392],\n",
       "       [535.314  ],\n",
       "       [517.6269 ],\n",
       "       [603.93915],\n",
       "       [524.43146],\n",
       "       [333.35248],\n",
       "       [575.08826],\n",
       "       [430.88177],\n",
       "       [561.4949 ],\n",
       "       [512.40497],\n",
       "       [390.23242],\n",
       "       [565.18677],\n",
       "       [453.86935],\n",
       "       [447.5639 ],\n",
       "       [639.80554],\n",
       "       [523.36273],\n",
       "       [549.6422 ],\n",
       "       [416.80954],\n",
       "       [477.78314],\n",
       "       [585.43396],\n",
       "       [666.1881 ],\n",
       "       [699.2338 ],\n",
       "       [658.2156 ],\n",
       "       [559.5084 ],\n",
       "       [502.1873 ],\n",
       "       [389.50473],\n",
       "       [280.6229 ],\n",
       "       [478.65604],\n",
       "       [615.2471 ],\n",
       "       [372.48404],\n",
       "       [511.2632 ],\n",
       "       [510.03098],\n",
       "       [492.5109 ],\n",
       "       [479.5002 ],\n",
       "       [422.89957],\n",
       "       [492.48276],\n",
       "       [470.52325],\n",
       "       [599.34326],\n",
       "       [572.50995],\n",
       "       [414.08585],\n",
       "       [629.5061 ],\n",
       "       [465.4303 ],\n",
       "       [563.27716],\n",
       "       [404.81842],\n",
       "       [531.15405],\n",
       "       [571.56604],\n",
       "       [356.26843],\n",
       "       [548.79346],\n",
       "       [602.2492 ],\n",
       "       [383.46005],\n",
       "       [541.3593 ],\n",
       "       [561.53705],\n",
       "       [451.96045],\n",
       "       [631.0629 ],\n",
       "       [371.42603],\n",
       "       [473.3026 ],\n",
       "       [527.8522 ],\n",
       "       [371.4725 ],\n",
       "       [460.30264],\n",
       "       [435.40735],\n",
       "       [497.5153 ],\n",
       "       [345.31808],\n",
       "       [394.43573],\n",
       "       [603.4746 ],\n",
       "       [505.66476],\n",
       "       [467.671  ],\n",
       "       [489.3973 ],\n",
       "       [534.2562 ],\n",
       "       [343.70496],\n",
       "       [511.3285 ],\n",
       "       [250.12213],\n",
       "       [503.10153],\n",
       "       [540.0716 ],\n",
       "       [488.4026 ],\n",
       "       [470.14163],\n",
       "       [391.6969 ],\n",
       "       [415.3741 ],\n",
       "       [548.5365 ],\n",
       "       [474.84207],\n",
       "       [578.87054],\n",
       "       [488.80283],\n",
       "       [599.8828 ],\n",
       "       [545.9595 ],\n",
       "       [540.9319 ],\n",
       "       [499.60062],\n",
       "       [644.68054],\n",
       "       [559.3638 ],\n",
       "       [576.86395],\n",
       "       [443.21732],\n",
       "       [414.6402 ],\n",
       "       [419.15274],\n",
       "       [568.0597 ],\n",
       "       [607.9004 ],\n",
       "       [436.85202],\n",
       "       [487.00482],\n",
       "       [586.66583],\n",
       "       [524.37134],\n",
       "       [356.55518],\n",
       "       [644.2623 ],\n",
       "       [527.02014],\n",
       "       [336.4279 ],\n",
       "       [491.72012],\n",
       "       [409.28293],\n",
       "       [605.4928 ],\n",
       "       [345.73816],\n",
       "       [521.4105 ],\n",
       "       [403.82388],\n",
       "       [257.72568],\n",
       "       [518.8917 ],\n",
       "       [340.10715],\n",
       "       [361.23325],\n",
       "       [575.3466 ],\n",
       "       [415.79468],\n",
       "       [549.94574],\n",
       "       [520.07886],\n",
       "       [509.76596],\n",
       "       [323.9819 ],\n",
       "       [403.2864 ],\n",
       "       [601.2971 ],\n",
       "       [616.7385 ],\n",
       "       [602.16626],\n",
       "       [565.2309 ],\n",
       "       [472.4789 ],\n",
       "       [459.4362 ],\n",
       "       [507.44174],\n",
       "       [444.98795],\n",
       "       [510.31985],\n",
       "       [501.39548],\n",
       "       [399.27798],\n",
       "       [604.4218 ],\n",
       "       [257.44684],\n",
       "       [627.1184 ],\n",
       "       [588.0471 ],\n",
       "       [326.37466],\n",
       "       [478.59323],\n",
       "       [594.25085],\n",
       "       [377.5621 ],\n",
       "       [459.2217 ],\n",
       "       [324.23932],\n",
       "       [517.69025],\n",
       "       [408.74625],\n",
       "       [555.20154],\n",
       "       [640.7399 ],\n",
       "       [535.7993 ],\n",
       "       [502.19327],\n",
       "       [633.8959 ],\n",
       "       [514.2426 ],\n",
       "       [530.6898 ],\n",
       "       [517.82104],\n",
       "       [456.5107 ],\n",
       "       [504.8407 ],\n",
       "       [460.17203],\n",
       "       [590.6105 ],\n",
       "       [464.97195],\n",
       "       [426.28836],\n",
       "       [540.56177],\n",
       "       [492.82846],\n",
       "       [678.4685 ],\n",
       "       [371.93924],\n",
       "       [550.5684 ],\n",
       "       [576.8919 ],\n",
       "       [433.06387],\n",
       "       [541.99194],\n",
       "       [584.9159 ],\n",
       "       [578.1723 ],\n",
       "       [719.694  ],\n",
       "       [431.84247],\n",
       "       [397.7358 ],\n",
       "       [313.2509 ],\n",
       "       [447.36304],\n",
       "       [387.24063],\n",
       "       [542.1715 ],\n",
       "       [521.7274 ],\n",
       "       [563.4305 ],\n",
       "       [447.0958 ],\n",
       "       [533.38715],\n",
       "       [380.95084],\n",
       "       [500.53287],\n",
       "       [635.9597 ],\n",
       "       [495.57333],\n",
       "       [567.32733],\n",
       "       [469.16513],\n",
       "       [272.6011 ],\n",
       "       [516.36145],\n",
       "       [620.27374],\n",
       "       [349.71097],\n",
       "       [449.52255],\n",
       "       [498.30856],\n",
       "       [541.94116],\n",
       "       [610.7113 ],\n",
       "       [387.32864],\n",
       "       [448.47812],\n",
       "       [481.4529 ],\n",
       "       [597.2157 ],\n",
       "       [498.39957],\n",
       "       [320.68997],\n",
       "       [554.09753],\n",
       "       [443.7159 ],\n",
       "       [528.01917],\n",
       "       [514.31665],\n",
       "       [608.5303 ],\n",
       "       [416.0701 ],\n",
       "       [409.9942 ]], dtype=float32)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_df = pd.DataFrame(y_test,columns=['Test Y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "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]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_predictions = pd.Series(test_predictions.reshape(300,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      404.416748\n",
       "1      622.400757\n",
       "2      591.032349\n",
       "3      571.147400\n",
       "4      365.785919\n",
       "          ...    \n",
       "295    528.019165\n",
       "296    514.316650\n",
       "297    608.530273\n",
       "298    416.070099\n",
       "299    409.994202\n",
       "Length: 300, dtype: float32"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_df = pd.concat([pred_df,test_predictions],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_df.columns = ['Test Y','Model Predictions']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "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.416748</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>624.156198</td>\n",
       "      <td>622.400757</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>582.455066</td>\n",
       "      <td>591.032349</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>578.588606</td>\n",
       "      <td>571.147400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>371.224104</td>\n",
       "      <td>365.785919</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.019165</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>296</th>\n",
       "      <td>502.909473</td>\n",
       "      <td>514.316650</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>297</th>\n",
       "      <td>612.727910</td>\n",
       "      <td>608.530273</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>298</th>\n",
       "      <td>417.569725</td>\n",
       "      <td>416.070099</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>299</th>\n",
       "      <td>410.538250</td>\n",
       "      <td>409.994202</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.416748\n",
       "1    624.156198         622.400757\n",
       "2    582.455066         591.032349\n",
       "3    578.588606         571.147400\n",
       "4    371.224104         365.785919\n",
       "..          ...                ...\n",
       "295  525.704657         528.019165\n",
       "296  502.909473         514.316650\n",
       "297  612.727910         608.530273\n",
       "298  417.569725         416.070099\n",
       "299  410.538250         409.994202\n",
       "\n",
       "[300 rows x 2 columns]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare to the real test labels!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f6114122790>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.scatterplot(x='Test Y',y='Model Predictions',data=pred_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_df['Error'] = pred_df['Test Y'] - pred_df['Model Predictions']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f60e05c1ad0>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(pred_df['Error'],bins=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import mean_absolute_error,mean_squared_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0621301002868355"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_absolute_error(pred_df['Test Y'],pred_df['Model Predictions'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.70388581161478"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mean_squared_error(pred_df['Test Y'],pred_df['Model Predictions'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.703882217407227"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Essentially the same thing, difference just due to precision\n",
    "test_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0698996259696525"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# RMSE\n",
    "test_score**0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# [[Feature1, Feature2]]\n",
    "new_gem = [[998,1000]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.14117652, 0.53968792]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Don't forget to scale!\n",
    "scaler.transform(new_gem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_gem = scaler.transform(new_gem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[418.79172]], dtype=float32)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict(new_gem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving and Loading a Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import load_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "later_model = load_model('my_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[418.79172]], dtype=float32)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "later_model.predict(new_gem)"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}