introduction_to_ann_with_keras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Introduction to Artificial Neural Networks with Keras**\n",
    "\n",
    "This notebook is inspired from the handson-ml2 GitHub repository by Aurélien Geron\n",
    "\n",
    "https://github.com/ageron/handson-ml2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's import a few common modules, ensure MatplotLib plots figures inline and prepare a function to save the figures. We also check that Python 3.5 or later is installed (although Python 2.x may work, it is deprecated so we strongly recommend you use Python 3 instead), as well as Scikit-Learn ≥0.20 and TensorFlow ≥2.0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python ≥3.5 is required\n",
    "import sys\n",
    "assert sys.version_info >= (3, 5)\n",
    "\n",
    "# Scikit-Learn ≥0.20 is required\n",
    "import sklearn\n",
    "assert sklearn.__version__ >= \"0.20\"\n",
    "\n",
    "try:\n",
    "    # %tensorflow_version only exists in Colab.\n",
    "    %tensorflow_version 2.x\n",
    "except Exception:\n",
    "    pass\n",
    "\n",
    "# TensorFlow ≥2.0 is required\n",
    "import tensorflow as tf\n",
    "assert tf.__version__ >= \"2.0\"\n",
    "\n",
    "# Common imports\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "# to make this notebook's output stable across runs\n",
    "np.random.seed(42)\n",
    "\n",
    "# To plot pretty figures\n",
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "mpl.rc('axes', labelsize=14)\n",
    "mpl.rc('xtick', labelsize=12)\n",
    "mpl.rc('ytick', labelsize=12)\n",
    "\n",
    "# Where to save the figures\n",
    "PROJECT_ROOT_DIR = \".\"\n",
    "CHAPTER_ID = \"ann\"\n",
    "IMAGES_PATH = os.path.join(PROJECT_ROOT_DIR, \"images\", CHAPTER_ID)\n",
    "os.makedirs(IMAGES_PATH, exist_ok=True)\n",
    "\n",
    "def save_fig(fig_id, tight_layout=True, fig_extension=\"png\", resolution=300):\n",
    "    path = os.path.join(IMAGES_PATH, fig_id + \".\" + fig_extension)\n",
    "    print(\"Saving figure\", fig_id)\n",
    "    if tight_layout:\n",
    "        plt.tight_layout()\n",
    "    plt.savefig(path, format=fig_extension, dpi=resolution)\n",
    "\n",
    "# Ignore useless warnings (see SciPy issue #5998)\n",
    "import warnings\n",
    "warnings.filterwarnings(action=\"ignore\", message=\"^internal gelsd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Perceptrons"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: we set `max_iter` and `tol` explicitly to avoid warnings about the fact that their default value will change in future versions of Scikit-Learn."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the libraries\n",
    "import numpy as np\n",
    "from sklearn.datasets import load_iris # contains the Iris dataset\n",
    "from sklearn.linear_model import Perceptron # Perceptron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the Iris dataset\n",
    "iris = load_iris() # load dataset\n",
    "X = iris.data[:, (2, 3)]  # consider only the petal length, petal width\n",
    "y = (iris.target == 0).astype(np.int) # predicting only Iris-setosa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.4, 0.2],\n",
       "       [1.4, 0.2],\n",
       "       [1.3, 0.2],\n",
       "       [1.5, 0.2],\n",
       "       [1.4, 0.2],\n",
       "       [1.7, 0.4],\n",
       "       [1.4, 0.3],\n",
       "       [1.5, 0.2],\n",
       "       [1.4, 0.2],\n",
       "       [1.5, 0.1],\n",
       "       [1.5, 0.2],\n",
       "       [1.6, 0.2],\n",
       "       [1.4, 0.1],\n",
       "       [1.1, 0.1],\n",
       "       [1.2, 0.2],\n",
       "       [1.5, 0.4],\n",
       "       [1.3, 0.4],\n",
       "       [1.4, 0.3],\n",
       "       [1.7, 0.3],\n",
       "       [1.5, 0.3],\n",
       "       [1.7, 0.2],\n",
       "       [1.5, 0.4],\n",
       "       [1. , 0.2],\n",
       "       [1.7, 0.5],\n",
       "       [1.9, 0.2],\n",
       "       [1.6, 0.2],\n",
       "       [1.6, 0.4],\n",
       "       [1.5, 0.2],\n",
       "       [1.4, 0.2],\n",
       "       [1.6, 0.2],\n",
       "       [1.6, 0.2],\n",
       "       [1.5, 0.4],\n",
       "       [1.5, 0.1],\n",
       "       [1.4, 0.2],\n",
       "       [1.5, 0.2],\n",
       "       [1.2, 0.2],\n",
       "       [1.3, 0.2],\n",
       "       [1.4, 0.1],\n",
       "       [1.3, 0.2],\n",
       "       [1.5, 0.2],\n",
       "       [1.3, 0.3],\n",
       "       [1.3, 0.3],\n",
       "       [1.3, 0.2],\n",
       "       [1.6, 0.6],\n",
       "       [1.9, 0.4],\n",
       "       [1.4, 0.3],\n",
       "       [1.6, 0.2],\n",
       "       [1.4, 0.2],\n",
       "       [1.5, 0.2],\n",
       "       [1.4, 0.2],\n",
       "       [4.7, 1.4],\n",
       "       [4.5, 1.5],\n",
       "       [4.9, 1.5],\n",
       "       [4. , 1.3],\n",
       "       [4.6, 1.5],\n",
       "       [4.5, 1.3],\n",
       "       [4.7, 1.6],\n",
       "       [3.3, 1. ],\n",
       "       [4.6, 1.3],\n",
       "       [3.9, 1.4],\n",
       "       [3.5, 1. ],\n",
       "       [4.2, 1.5],\n",
       "       [4. , 1. ],\n",
       "       [4.7, 1.4],\n",
       "       [3.6, 1.3],\n",
       "       [4.4, 1.4],\n",
       "       [4.5, 1.5],\n",
       "       [4.1, 1. ],\n",
       "       [4.5, 1.5],\n",
       "       [3.9, 1.1],\n",
       "       [4.8, 1.8],\n",
       "       [4. , 1.3],\n",
       "       [4.9, 1.5],\n",
       "       [4.7, 1.2],\n",
       "       [4.3, 1.3],\n",
       "       [4.4, 1.4],\n",
       "       [4.8, 1.4],\n",
       "       [5. , 1.7],\n",
       "       [4.5, 1.5],\n",
       "       [3.5, 1. ],\n",
       "       [3.8, 1.1],\n",
       "       [3.7, 1. ],\n",
       "       [3.9, 1.2],\n",
       "       [5.1, 1.6],\n",
       "       [4.5, 1.5],\n",
       "       [4.5, 1.6],\n",
       "       [4.7, 1.5],\n",
       "       [4.4, 1.3],\n",
       "       [4.1, 1.3],\n",
       "       [4. , 1.3],\n",
       "       [4.4, 1.2],\n",
       "       [4.6, 1.4],\n",
       "       [4. , 1.2],\n",
       "       [3.3, 1. ],\n",
       "       [4.2, 1.3],\n",
       "       [4.2, 1.2],\n",
       "       [4.2, 1.3],\n",
       "       [4.3, 1.3],\n",
       "       [3. , 1.1],\n",
       "       [4.1, 1.3],\n",
       "       [6. , 2.5],\n",
       "       [5.1, 1.9],\n",
       "       [5.9, 2.1],\n",
       "       [5.6, 1.8],\n",
       "       [5.8, 2.2],\n",
       "       [6.6, 2.1],\n",
       "       [4.5, 1.7],\n",
       "       [6.3, 1.8],\n",
       "       [5.8, 1.8],\n",
       "       [6.1, 2.5],\n",
       "       [5.1, 2. ],\n",
       "       [5.3, 1.9],\n",
       "       [5.5, 2.1],\n",
       "       [5. , 2. ],\n",
       "       [5.1, 2.4],\n",
       "       [5.3, 2.3],\n",
       "       [5.5, 1.8],\n",
       "       [6.7, 2.2],\n",
       "       [6.9, 2.3],\n",
       "       [5. , 1.5],\n",
       "       [5.7, 2.3],\n",
       "       [4.9, 2. ],\n",
       "       [6.7, 2. ],\n",
       "       [4.9, 1.8],\n",
       "       [5.7, 2.1],\n",
       "       [6. , 1.8],\n",
       "       [4.8, 1.8],\n",
       "       [4.9, 1.8],\n",
       "       [5.6, 2.1],\n",
       "       [5.8, 1.6],\n",
       "       [6.1, 1.9],\n",
       "       [6.4, 2. ],\n",
       "       [5.6, 2.2],\n",
       "       [5.1, 1.5],\n",
       "       [5.6, 1.4],\n",
       "       [6.1, 2.3],\n",
       "       [5.6, 2.4],\n",
       "       [5.5, 1.8],\n",
       "       [4.8, 1.8],\n",
       "       [5.4, 2.1],\n",
       "       [5.6, 2.4],\n",
       "       [5.1, 2.3],\n",
       "       [5.1, 1.9],\n",
       "       [5.9, 2.3],\n",
       "       [5.7, 2.5],\n",
       "       [5.2, 2.3],\n",
       "       [5. , 1.9],\n",
       "       [5.2, 2. ],\n",
       "       [5.4, 2.3],\n",
       "       [5.1, 1.8]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Perceptron(alpha=0.0001, class_weight=None, early_stopping=False, eta0=1.0,\n",
       "           fit_intercept=True, max_iter=1000, n_iter_no_change=5, n_jobs=None,\n",
       "           penalty=None, random_state=42, shuffle=True, tol=0.001,\n",
       "           validation_fraction=0.1, verbose=0, warm_start=False)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training the Perceptron on the Iris dataset\n",
    "per_clf = Perceptron(max_iter=1000, tol=1e-3, random_state=42) # creating model\n",
    "per_clf.fit(X, y) # training model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predicting using our model\n",
    "y_pred = per_clf.predict([[2, 0.5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting prediction of Iris-Setosa vs Not Iris-Setosa\n",
    "\n",
    "a = -per_clf.coef_[0][0] / per_clf.coef_[0][1]\n",
    "b = -per_clf.intercept_ / per_clf.coef_[0][1]\n",
    "\n",
    "axes = [0, 5, 0, 2]\n",
    "\n",
    "# meshgrid function is used to create a rectangular grid out of two given\n",
    "# one-dimensional arrays representing the Cartesian indexing or Matrix indexing\n",
    "\n",
    "x0, x1 = np.meshgrid(\n",
    "        np.linspace(axes[0], axes[1], 500).reshape(-1, 1),\n",
    "        np.linspace(axes[2], axes[3], 200).reshape(-1, 1),\n",
    "    )\n",
    "\n",
    "# ravel returns contiguous flattened array\n",
    "# (1D array with all the input-array elements and with the same type as it)\n",
    "\n",
    "X_new = np.c_[x0.ravel(), x1.ravel()] # Translates slice objects to concatenation along the second axis.\n",
    "y_predict = per_clf.predict(X_new)\n",
    "zz = y_predict.reshape(x0.shape)\n",
    "\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.plot(X[y==0, 0], X[y==0, 1], \"bs\", label=\"Not Iris-Setosa\")\n",
    "plt.plot(X[y==1, 0], X[y==1, 1], \"yo\", label=\"Iris-Setosa\")\n",
    "\n",
    "plt.plot([axes[0], axes[1]], [a * axes[0] + b, a * axes[1] + b], \"k-\", linewidth=3)\n",
    "from matplotlib.colors import ListedColormap\n",
    "custom_cmap = ListedColormap(['#9898ff', '#fafab0'])\n",
    "\n",
    "plt.contourf(x0, x1, zz, cmap=custom_cmap)\n",
    "plt.xlabel(\"Petal length\", fontsize=14)\n",
    "plt.ylabel(\"Petal width\", fontsize=14)\n",
    "plt.legend(loc=\"lower right\", fontsize=14)\n",
    "plt.axis(axes)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Activation functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    return 1 / (1 + np.exp(-z))\n",
    "\n",
    "def relu(z):\n",
    "    return np.maximum(0, z)\n",
    "\n",
    "def derivative(f, z, eps=0.000001):\n",
    "    return (f(z + eps) - f(z - eps))/(2 * eps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting the Activation functions and their derivatives\n",
    "\n",
    "z = np.linspace(-5, 5, 200)\n",
    "\n",
    "plt.figure(figsize=(11,4))\n",
    "\n",
    "# first plot\n",
    "\n",
    "plt.subplot(121)\n",
    "plt.plot(z, np.sign(z), \"r-\", linewidth=1, label=\"Step\")\n",
    "plt.plot(z, sigmoid(z), \"g--\", linewidth=2, label=\"Sigmoid\")\n",
    "plt.plot(z, np.tanh(z), \"b-\", linewidth=2, label=\"Tanh\")\n",
    "plt.plot(z, relu(z), \"m-.\", linewidth=2, label=\"ReLU\")\n",
    "plt.grid(True)\n",
    "plt.legend(loc=\"center right\", fontsize=14)\n",
    "plt.title(\"Activation functions\", fontsize=14)\n",
    "plt.axis([-5, 5, -1.2, 1.2])\n",
    "\n",
    "# second plot\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.plot(z, derivative(np.sign, z), \"r-\", linewidth=1, label=\"Step\")\n",
    "plt.plot(0, 0, \"ro\", markersize=5)\n",
    "plt.plot(0, 0, \"rx\", markersize=10)\n",
    "plt.plot(z, derivative(sigmoid, z), \"g--\", linewidth=2, label=\"Sigmoid\")\n",
    "plt.plot(z, derivative(np.tanh, z), \"b-\", linewidth=2, label=\"Tanh\")\n",
    "plt.plot(z, derivative(relu, z), \"m-.\", linewidth=2, label=\"ReLU\")\n",
    "plt.grid(True)\n",
    "plt.title(\"Derivatives\", fontsize=14)\n",
    "plt.axis([-5, 5, -0.2, 1.2])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def heaviside(z):\n",
    "    return (z >= 0).astype(z.dtype)\n",
    "\n",
    "def mlp_xor(x1, x2, activation=heaviside):\n",
    "    a = activation(x1 + x2 - 1.5)\n",
    "    b = activation(x1 + x2 - 0.5)\n",
    "    return activation(-a + b - 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plotting the Heaviside and Sigmoid function\n",
    "\n",
    "x1s = np.linspace(-0.2, 1.2, 100)\n",
    "x2s = np.linspace(-0.2, 1.2, 100)\n",
    "x1, x2 = np.meshgrid(x1s, x2s)\n",
    "\n",
    "z1 = mlp_xor(x1, x2, activation=heaviside)\n",
    "z2 = mlp_xor(x1, x2, activation=sigmoid)\n",
    "\n",
    "plt.figure(figsize=(10,4))\n",
    "\n",
    "# first plot\n",
    "\n",
    "plt.subplot(121)\n",
    "plt.contourf(x1, x2, z1)\n",
    "plt.plot([0, 1], [0, 1], \"gs\", markersize=20)\n",
    "plt.plot([0, 1], [1, 0], \"y^\", markersize=20)\n",
    "plt.title(\"Activation function: heaviside\", fontsize=14)\n",
    "plt.grid(True)\n",
    "\n",
    "# second plot\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.contourf(x1, x2, z2)\n",
    "plt.plot([0, 1], [0, 1], \"gs\", markersize=20)\n",
    "plt.plot([0, 1], [1, 0], \"y^\", markersize=20)\n",
    "plt.title(\"Activation function: sigmoid\", fontsize=14)\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.52497919, 0.47502081])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.exp([0.4, 0.3])\n",
    "a/np.sum(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building an Image Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First let's import TensorFlow and Keras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.4918247 , 1.34985881])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp([0.4, 0.3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.1.0'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.2.4-tf'"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keras.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start by loading the fashion MNIST dataset. Keras has a number of functions to load popular datasets in `keras.datasets`. The dataset is already split for you between a training set and a test set, but it can be useful to split the training set further to have a validation set:\n",
    "\n",
    "\n",
    "For more infor: https://github.com/zalandoresearch/fashion-mnist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "fashion_mnist = keras.datasets.fashion_mnist # loading the dataset\n",
    "(X_train_full, y_train_full), (X_test, y_test) = fashion_mnist.load_data() # sorting into test and train set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The training set contains 60,000 grayscale images, each 28x28 pixels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_full.shape # checking the shape of the training set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each pixel intensity is represented as a byte (0 to 255):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('uint8')"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_full.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's split the full training set into a validation set and a (smaller) training set. We also scale the pixel intensities down to the 0-1 range and convert them to floats, by dividing by 255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_valid, X_train = X_train_full[:5000] / 255., X_train_full[5000:] / 255.\n",
    "y_valid, y_train = y_train_full[:5000], y_train_full[5000:]\n",
    "X_test = X_test / 255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can plot an image using Matplotlib's `imshow()` function, with a `'binary'`\n",
    " color map:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "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": [
    "plt.imshow(X_train[0], cmap=\"binary\")\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The labels are the class IDs (represented as uint8), from 0 to 9:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = a[1:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "b[0] = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, 20,  3])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 0, 7, ..., 3, 0, 5], dtype=uint8)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are the corresponding class names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_names = [\"T-shirt/top\", \"Trouser\", \"Pullover\", \"Dress\", \"Coat\",\n",
    "               \"Sandal\", \"Shirt\", \"Sneaker\", \"Bag\", \"Ankle boot\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the first image in the training set is a coat:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Coat'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_names[y_train[0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The validation set contains 5,000 images, and the test set contains 10,000 images:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5000, 28, 28)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_valid.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10000, 28, 28)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at a sample of the images in the dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x345.6 with 40 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_rows = 4\n",
    "n_cols = 10\n",
    "plt.figure(figsize=(n_cols * 1.2, n_rows * 1.2))\n",
    "for row in range(n_rows):\n",
    "    for col in range(n_cols):\n",
    "        index = n_cols * row + col\n",
    "        plt.subplot(n_rows, n_cols, index + 1)\n",
    "        plt.imshow(X_train[index], cmap=\"binary\", interpolation=\"nearest\")\n",
    "        plt.axis('off')\n",
    "        plt.title(class_names[y_train[index]], fontsize=12)\n",
    "plt.subplots_adjust(wspace=0.2, hspace=0.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a classification MLP with Keras' Sequential API\n",
    "\n",
    "model = keras.models.Sequential()\n",
    "model.add(keras.layers.Flatten(input_shape=[28, 28])) # flatten layer\n",
    "model.add(keras.layers.Dense(300, activation=\"relu\")) # dense layer 1\n",
    "model.add(keras.layers.Dense(100, activation=\"relu\")) # dense layer 2\n",
    "model.add(keras.layers.Dense(10, activation=\"softmax\")) # softmax layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(arr):\n",
    "    pos = np.exp(arr)\n",
    "    return pos/np.sum(pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 3.17997090e-22, 1.18506486e-27])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "softmax([50,0.5,-12])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Why do we need clear_session?**\n",
    "\n",
    "It is useful when you're creating multiple models in succession, such as during hyperparameter search or cross-validation. Each model you train adds nodes (potentially numbering in the thousands) to the graph. EVentually models will become slower and slower to train, and you may also run out of memory. Clearing the session removes all the nodes left over from previous models, freeing memory and preventing slowdown."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.302585092994046"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import log10\n",
    "def my_cross_entropy(actual, predicted):\n",
    "    return -np.dot(actual, log10(predicted))\n",
    "\n",
    "def binary_cross_entropy(actual, predicted):\n",
    "    return my_cross_entropy([actual, 1-actual], [predicted, 1-predicted])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.980043648054024"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_cross_entropy(0.01, 0.99)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.024321157348425586"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_cross_entropy(0.01, 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.044277509294401086"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_cross_entropy(0.02, 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.14118174150460758"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_cross_entropy(0.9, 0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9045757490560675"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_cross_entropy(0.9, 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "keras.backend.clear_session() # clearing session\n",
    "np.random.seed(42) # generating random see\n",
    "tf.random.set_seed(42) # set.seed function helps reuse same set of random variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Better way of doing it\n",
    "\n",
    "model = keras.models.Sequential([\n",
    "    keras.layers.Flatten(input_shape=[28, 28]),\n",
    "    keras.layers.Dense(300, activation=\"relu\"),\n",
    "    keras.layers.Dense(100, activation=\"relu\"),\n",
    "    keras.layers.Dense(10, activation=\"softmax\")\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tensorflow.python.keras.layers.core.Flatten at 0x7faa5c4a8fd0>,\n",
       " <tensorflow.python.keras.layers.core.Dense at 0x7faa5c4ab128>,\n",
       " <tensorflow.python.keras.layers.core.Dense at 0x7faa5c4ab320>,\n",
       " <tensorflow.python.keras.layers.core.Dense at 0x7faa5c4ab518>]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.layers # viewing the layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "flatten (Flatten)            (None, 784)               0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 300)               235500    \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 100)               30100     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 10)                1010      \n",
      "=================================================================\n",
      "Total params: 266,610\n",
      "Trainable params: 266,610\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary() # viewing the summary of the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keras.utils.plot_model(model, \"my_fashion_mnist_model.png\", show_shapes=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dense'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hidden1 = model.layers[1] # first layer\n",
    "hidden1.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.get_layer(hidden1.name) is hidden1 # checking if the layer is hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights, biases = hidden1.get_weights() # getting the weights and biases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.02448617, -0.00877795, -0.02189048, ..., -0.02766046,\n",
       "         0.03859074, -0.06889391],\n",
       "       [ 0.00476504, -0.03105379, -0.0586676 , ...,  0.00602964,\n",
       "        -0.02763776, -0.04165364],\n",
       "       [-0.06189284, -0.06901957,  0.07102345, ..., -0.04238207,\n",
       "         0.07121518, -0.07331658],\n",
       "       ...,\n",
       "       [-0.03048757,  0.02155137, -0.05400612, ..., -0.00113463,\n",
       "         0.00228987,  0.05581069],\n",
       "       [ 0.07061854, -0.06960931,  0.07038955, ..., -0.00384101,\n",
       "         0.00034875,  0.02878492],\n",
       "       [-0.06022581,  0.01577859, -0.02585464, ..., -0.00527829,\n",
       "         0.00272203, -0.06793761]], dtype=float32)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights # checking the weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(784, 300)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], dtype=float32)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biases # checking the biases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(300,)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biases.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = tf.keras.utils.to_categorical([1, 2, 0, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0.],\n",
       "       [1., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1.]], dtype=float32)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 0, 4])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(res, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "sgd = keras.optimizers.SGD(learning_rate=0.01)\n",
    "# Compiling the model we created\n",
    "\n",
    "model.compile(loss=\"sparse_categorical_crossentropy\",\n",
    "              optimizer=sgd,\n",
    "              metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is equivalent to:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "model.compile(loss=keras.losses.sparse_categorical_crossentropy,\n",
    "              optimizer=keras.optimizers.SGD(),\n",
    "              metrics=[keras.metrics.sparse_categorical_accuracy])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 55000 samples, validate on 5000 samples\n",
      "Epoch 1/30\n",
      "55000/55000 [==============================] - 5s 85us/sample - loss: 0.7226 - accuracy: 0.7641 - val_loss: 0.5073 - val_accuracy: 0.8320\n",
      "Epoch 2/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.4844 - accuracy: 0.8323 - val_loss: 0.4534 - val_accuracy: 0.8494\n",
      "Epoch 3/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.4414 - accuracy: 0.8463 - val_loss: 0.4393 - val_accuracy: 0.8496\n",
      "Epoch 4/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.4128 - accuracy: 0.8549 - val_loss: 0.4175 - val_accuracy: 0.8558\n",
      "Epoch 5/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.3926 - accuracy: 0.8616 - val_loss: 0.3810 - val_accuracy: 0.8656\n",
      "Epoch 6/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.3770 - accuracy: 0.8666 - val_loss: 0.3729 - val_accuracy: 0.8684\n",
      "Epoch 7/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.3626 - accuracy: 0.8729 - val_loss: 0.3703 - val_accuracy: 0.8708\n",
      "Epoch 8/30\n",
      "55000/55000 [==============================] - 4s 79us/sample - loss: 0.3517 - accuracy: 0.8746 - val_loss: 0.3658 - val_accuracy: 0.8706\n",
      "Epoch 9/30\n",
      "55000/55000 [==============================] - 4s 79us/sample - loss: 0.3421 - accuracy: 0.8770 - val_loss: 0.3434 - val_accuracy: 0.8780\n",
      "Epoch 10/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.3326 - accuracy: 0.8810 - val_loss: 0.3507 - val_accuracy: 0.8784\n",
      "Epoch 11/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.3241 - accuracy: 0.8835 - val_loss: 0.3354 - val_accuracy: 0.8812\n",
      "Epoch 12/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.3160 - accuracy: 0.8868 - val_loss: 0.3322 - val_accuracy: 0.8838\n",
      "Epoch 13/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.3073 - accuracy: 0.8901 - val_loss: 0.3317 - val_accuracy: 0.8820\n",
      "Epoch 14/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.3018 - accuracy: 0.8924 - val_loss: 0.3239 - val_accuracy: 0.8872\n",
      "Epoch 15/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.2954 - accuracy: 0.8937 - val_loss: 0.3161 - val_accuracy: 0.8900\n",
      "Epoch 16/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.2898 - accuracy: 0.8962 - val_loss: 0.3238 - val_accuracy: 0.8874\n",
      "Epoch 17/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.2835 - accuracy: 0.8989 - val_loss: 0.3161 - val_accuracy: 0.8912\n",
      "Epoch 18/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2783 - accuracy: 0.8998 - val_loss: 0.3098 - val_accuracy: 0.8904\n",
      "Epoch 19/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2731 - accuracy: 0.9019 - val_loss: 0.3185 - val_accuracy: 0.8852\n",
      "Epoch 20/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2680 - accuracy: 0.9039 - val_loss: 0.3202 - val_accuracy: 0.8854\n",
      "Epoch 21/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.2637 - accuracy: 0.9047 - val_loss: 0.2990 - val_accuracy: 0.8942\n",
      "Epoch 22/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2577 - accuracy: 0.9076 - val_loss: 0.3099 - val_accuracy: 0.8884\n",
      "Epoch 23/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2542 - accuracy: 0.9086 - val_loss: 0.2991 - val_accuracy: 0.8910\n",
      "Epoch 24/30\n",
      "55000/55000 [==============================] - 4s 79us/sample - loss: 0.2494 - accuracy: 0.9107 - val_loss: 0.3092 - val_accuracy: 0.8860\n",
      "Epoch 25/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2454 - accuracy: 0.9125 - val_loss: 0.3088 - val_accuracy: 0.8888\n",
      "Epoch 26/30\n",
      "55000/55000 [==============================] - 4s 77us/sample - loss: 0.2410 - accuracy: 0.9144 - val_loss: 0.3223 - val_accuracy: 0.8860\n",
      "Epoch 27/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2368 - accuracy: 0.9153 - val_loss: 0.3127 - val_accuracy: 0.8866\n",
      "Epoch 28/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2324 - accuracy: 0.9175 - val_loss: 0.2919 - val_accuracy: 0.8940\n",
      "Epoch 29/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2290 - accuracy: 0.9184 - val_loss: 0.2999 - val_accuracy: 0.8922\n",
      "Epoch 30/30\n",
      "55000/55000 [==============================] - 4s 78us/sample - loss: 0.2258 - accuracy: 0.9193 - val_loss: 0.3030 - val_accuracy: 0.8902\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(X_train, y_train, epochs=30,\n",
    "                    validation_data=(X_valid, y_valid)) # fitting the model to training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'batch_size': 32,\n",
       " 'epochs': 30,\n",
       " 'steps': 1719,\n",
       " 'samples': 55000,\n",
       " 'verbose': 0,\n",
       " 'do_validation': True,\n",
       " 'metrics': ['loss', 'accuracy', 'val_loss', 'val_accuracy']}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history.params # getting the param history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]\n"
     ]
    }
   ],
   "source": [
    "print(history.epoch) # epoch history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history.history.keys() # printing the history keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the mean training loss and accuracy measured over each epoch\n",
    "# and the mean validation loss and accuracy measured at the end of each epoch\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "pd.DataFrame(history.history).plot(figsize=(8, 5))\n",
    "plt.grid(True)\n",
    "plt.gca().set_ylim(0, 1) # setting limits for y-axis\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000/10000 [==============================] - 1s 59us/sample - loss: 0.3362\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.33624030063152316, 0.8818667]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(X_test, y_test) # Evaluating the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['T-shirt/top',\n",
       " 'Trouser',\n",
       " 'Pullover',\n",
       " 'Dress',\n",
       " 'Coat',\n",
       " 'Sandal',\n",
       " 'Shirt',\n",
       " 'Sneaker',\n",
       " 'Bag',\n",
       " 'Ankle boot']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.01, 0.  , 0.98],\n",
       "       [0.  , 0.  , 0.99, 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  ],\n",
       "       [0.  , 1.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  ]],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# predicting first 3 elements\n",
    "\n",
    "X_new = X_test[:3]\n",
    "y_proba = model.predict(X_new)\n",
    "y_proba.round(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fe424d88978>"
      ]
     },
     "execution_count": 69,
     "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": [
    "plt.imshow(X_new[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 2, 1])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(y_proba.round(2), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 2, 1])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# predicting the class of these 3 elements\n",
    "\n",
    "y_pred = model.predict_classes(X_new)\n",
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Ankle boot', 'Pullover', 'Trouser'], dtype='<U11')"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(class_names)[y_pred] # getting the class names of the predicted elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 2, 1], dtype=uint8)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_new = y_test[:3] # evaluating the prediction by matching with y_test\n",
    "y_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 518.4x172.8 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting the predicted elements\n",
    "\n",
    "plt.figure(figsize=(7.2, 2.4))\n",
    "for index, image in enumerate(X_new):\n",
    "    plt.subplot(1, 3, index + 1)\n",
    "    plt.imshow(image, cmap=\"binary\", interpolation=\"nearest\")\n",
    "    plt.axis('off')\n",
    "    plt.title(class_names[y_test[index]], fontsize=12)\n",
    "plt.subplots_adjust(wspace=0.2, hspace=0.5)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regression MLP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's load, split and scale the California housing dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_california_housing\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "housing = fetch_california_housing() # loading the California Housing dataset\n",
    "\n",
    "X_train_full, X_test, y_train_full, y_test = train_test_split(housing.data, housing.target, random_state=42) # test and train\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X_train_full, y_train_full, random_state=42) # training and validation\n",
    "\n",
    "# Using the StandardScaler to scale the dataset\n",
    "\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_valid = scaler.transform(X_valid)\n",
    "X_test = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((11610, 8), (3870, 8), (5160, 8))"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, X_valid.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42) # generating random see\n",
    "tf.random.set_seed(42) # setting random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/20\n",
      "11610/11610 [==============================] - 1s 78us/sample - loss: 1.6205 - val_loss: 2.0374\n",
      "Epoch 2/20\n",
      "11610/11610 [==============================] - 1s 55us/sample - loss: 0.7162 - val_loss: 0.6571\n",
      "Epoch 3/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.6356 - val_loss: 0.5996\n",
      "Epoch 4/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.5989 - val_loss: 0.5662\n",
      "Epoch 5/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.5713 - val_loss: 0.5489\n",
      "Epoch 6/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.5491 - val_loss: 0.5204\n",
      "Epoch 7/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.5301 - val_loss: 0.5018\n",
      "Epoch 8/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.5142 - val_loss: 0.4815\n",
      "Epoch 9/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.5004 - val_loss: 0.4695\n",
      "Epoch 10/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4883 - val_loss: 0.4605\n",
      "Epoch 11/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4786 - val_loss: 0.4495\n",
      "Epoch 12/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4697 - val_loss: 0.4382\n",
      "Epoch 13/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4621 - val_loss: 0.4309\n",
      "Epoch 14/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.4556 - val_loss: 0.4247\n",
      "Epoch 15/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.4497 - val_loss: 0.4200\n",
      "Epoch 16/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.4443 - val_loss: 0.4149\n",
      "Epoch 17/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4397 - val_loss: 0.4108\n",
      "Epoch 18/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.4354 - val_loss: 0.4059\n",
      "Epoch 19/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.4315 - val_loss: 0.4003\n",
      "Epoch 20/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4281 - val_loss: 0.3981\n",
      "5160/5160 [==============================] - 0s 25us/sample - loss: 0.4218\n"
     ]
    }
   ],
   "source": [
    "# Creating the model using the Sequential API\n",
    "\n",
    "model = keras.models.Sequential([\n",
    "    keras.layers.Dense(30, activation=\"relu\", input_shape=X_train.shape[1:]),\n",
    "    keras.layers.Dense(1)\n",
    "])\n",
    "model.compile(loss=\"mean_squared_error\", optimizer=keras.optimizers.SGD(lr=1e-3)) # compiling the model\n",
    "history = model.fit(X_train, y_train, epochs=20, validation_data=(X_valid, y_valid)) # fit the model\n",
    "mse_test = model.evaluate(X_test, y_test) # evaluating\n",
    "X_new = X_test[:3]\n",
    "y_pred = model.predict(X_new) # predicting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_3 (Dense)              (None, 30)                270       \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 1)                 31        \n",
      "=================================================================\n",
      "Total params: 301\n",
      "Trainable params: 301\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fit() method returns a History object containing the training parameters (history.params), the list of epochs it went through (history.epoch), and most importantly a dictionary (history.history) containing the loss and extra metrics it\n",
    "measured at the end of each epoch on the training set and on the validation set (if any)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "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": [
    "plt.plot(pd.DataFrame(history.history))\n",
    "plt.grid(True)\n",
    "plt.gca().set_ylim(0, 1) # setting y-axis limit\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.37310064],\n",
       "       [1.6790789 ],\n",
       "       [3.0817137 ]], dtype=float32)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred # printing the predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functional API"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not all neural network models are simply sequential. Some may have complex topologies. Some may have multiple inputs and/or multiple outputs. For example, a Wide & Deep neural network (see [paper](https://ai.google/research/pubs/pub45413)) connects all or part of the inputs directly to the output layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8,)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = keras.layers.Dense(30, activation=\"relu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def f(power):\n",
    "    def f1(y):\n",
    "        return math.pow(y, power)\n",
    "    return f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "nf = f(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8000.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nf(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "27000.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nf(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([2,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 2, 2])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([a, b])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(4,), dtype=int64, numpy=array([1, 1, 2, 2])>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keras.layers.concatenate([a, b])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining the layers\n",
    "\n",
    "input_ = keras.layers.Input(shape=X_train.shape[1:])\n",
    "hidden1 = keras.layers.Dense(30, activation=\"relu\")(input_)\n",
    "hidden2 = keras.layers.Dense(30, activation=\"relu\")(hidden1)\n",
    "concat = keras.layers.concatenate([input_, hidden2]) # concatenate inputs\n",
    "output = keras.layers.Dense(1)(concat)\n",
    "model = keras.models.Model(inputs=[input_], outputs=[output])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_1 (InputLayer)            [(None, 8)]          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "dense_4 (Dense)                 (None, 30)           270         input_1[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "dense_5 (Dense)                 (None, 30)           930         dense_4[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "concatenate_1 (Concatenate)     (None, 38)           0           input_1[0][0]                    \n",
      "                                                                 dense_5[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "dense_6 (Dense)                 (None, 1)            39          concatenate_1[0][0]              \n",
      "==================================================================================================\n",
      "Total params: 1,239\n",
      "Trainable params: 1,239\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary() # generating model summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/20\n",
      "11610/11610 [==============================] - 1s 75us/sample - loss: 0.4278 - val_loss: 0.4040\n",
      "Epoch 2/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4243 - val_loss: 0.4078\n",
      "Epoch 3/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4211 - val_loss: 0.4084\n",
      "Epoch 4/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4182 - val_loss: 0.3985\n",
      "Epoch 5/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4155 - val_loss: 0.3985\n",
      "Epoch 6/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.4130 - val_loss: 0.4076\n",
      "Epoch 7/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4106 - val_loss: 0.3829\n",
      "Epoch 8/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.4084 - val_loss: 0.3828\n",
      "Epoch 9/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.4063 - val_loss: 0.3958\n",
      "Epoch 10/20\n",
      "11610/11610 [==============================] - 1s 54us/sample - loss: 0.4043 - val_loss: 0.3831\n",
      "Epoch 11/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.4025 - val_loss: 0.3756\n",
      "Epoch 12/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.4006 - val_loss: 0.3791\n",
      "Epoch 13/20\n",
      "11610/11610 [==============================] - 1s 53us/sample - loss: 0.3989 - val_loss: 0.3736\n",
      "Epoch 14/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.3976 - val_loss: 0.3701\n",
      "Epoch 15/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.3961 - val_loss: 0.4075\n",
      "Epoch 16/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.3949 - val_loss: 0.3678\n",
      "Epoch 17/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.3936 - val_loss: 0.3662\n",
      "Epoch 18/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.3921 - val_loss: 0.3808\n",
      "Epoch 19/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.3910 - val_loss: 0.3668\n",
      "Epoch 20/20\n",
      "11610/11610 [==============================] - 1s 52us/sample - loss: 0.3899 - val_loss: 0.3758\n",
      "5160/5160 [==============================] - 0s 26us/sample - loss: 0.3882\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss=\"mean_squared_error\", optimizer=keras.optimizers.SGD(lr=1e-3)) # compile model\n",
    "history = model.fit(X_train, y_train, epochs=20,\n",
    "                    validation_data=(X_valid, y_valid)) # fit model\n",
    "mse_test = model.evaluate(X_test, y_test) # evaluate model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model.predict(X_test) # predict using the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.72058403],\n",
       "       [1.7938155 ],\n",
       "       [3.5020304 ],\n",
       "       ...,\n",
       "       [1.4675169 ],\n",
       "       [2.0734572 ],\n",
       "       [3.982666  ]], dtype=float32)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if you want to send different subsets of input features through the wide or deep paths? We will send 5 features (features 0 to 4), and 6 through the deep path (features 2 to 7). Note that 3 features will go through both (features 2, 3 and 4)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating the model using different number of layers\n",
    "\n",
    "input_A = keras.layers.Input(shape=[5], name=\"wide_input\")\n",
    "input_B = keras.layers.Input(shape=[6], name=\"deep_input\")\n",
    "hidden1 = keras.layers.Dense(30, activation=\"relu\")(input_B)\n",
    "hidden2 = keras.layers.Dense(30, activation=\"relu\")(hidden1)\n",
    "concat = keras.layers.concatenate([input_A, hidden2]) # concatenate inputs\n",
    "output = keras.layers.Dense(1, name=\"output\")(concat)\n",
    "model = keras.models.Model(inputs=[input_A, input_B], outputs=[output])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(11610, 8)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1,2,3,4][2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/20\n",
      "11610/11610 [==============================] - 1s 85us/sample - loss: 1.8200 - val_loss: 1.9679\n",
      "Epoch 2/20\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.8075 - val_loss: 0.8335\n",
      "Epoch 3/20\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.6768 - val_loss: 0.6472\n",
      "Epoch 4/20\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.6185 - val_loss: 0.5872\n",
      "Epoch 5/20\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.5799 - val_loss: 0.5414\n",
      "Epoch 6/20\n",
      "11610/11610 [==============================] - 1s 59us/sample - loss: 0.5497 - val_loss: 0.5157\n",
      "Epoch 7/20\n",
      "11610/11610 [==============================] - 1s 60us/sample - loss: 0.5253 - val_loss: 0.4911\n",
      "Epoch 8/20\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.5049 - val_loss: 0.4698\n",
      "Epoch 9/20\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4881 - val_loss: 0.4559\n",
      "Epoch 10/20\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4749 - val_loss: 0.4431\n",
      "Epoch 11/20\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4644 - val_loss: 0.4336\n",
      "Epoch 12/20\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4562 - val_loss: 0.4282\n",
      "Epoch 13/20\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4504 - val_loss: 0.4215\n",
      "Epoch 14/20\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4464 - val_loss: 0.4188\n",
      "Epoch 15/20\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4429 - val_loss: 0.4310\n",
      "Epoch 16/20\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4401 - val_loss: 0.4197\n",
      "Epoch 17/20\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4381 - val_loss: 0.4100\n",
      "Epoch 18/20\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4356 - val_loss: 0.4203\n",
      "Epoch 19/20\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4339 - val_loss: 0.4228\n",
      "Epoch 20/20\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4321 - val_loss: 0.4173\n",
      "5160/5160 [==============================] - 0s 29us/sample - loss: 0.4245\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss=\"mse\", optimizer=keras.optimizers.SGD(lr=1e-3)) # compile the model\n",
    "\n",
    "X_train_A, X_train_B = X_train[:, :5], X_train[:, 2:]\n",
    "X_valid_A, X_valid_B = X_valid[:, :5], X_valid[:, 2:]\n",
    "X_test_A, X_test_B = X_test[:, :5], X_test[:, 2:]\n",
    "X_new_A, X_new_B = X_test_A[:3], X_test_B[:3]\n",
    "\n",
    "history = model.fit((X_train_A, X_train_B), y_train, epochs=20,\n",
    "                    validation_data=((X_valid_A, X_valid_B), y_valid))\n",
    "mse_test = model.evaluate((X_test_A, X_test_B), y_test)\n",
    "y_pred = model.predict((X_new_A, X_new_B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding an auxiliary output for regularization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_A = keras.layers.Input(shape=[5], name=\"wide_input\")\n",
    "input_B = keras.layers.Input(shape=[6], name=\"deep_input\")\n",
    "hidden1 = keras.layers.Dense(30, activation=\"relu\")(input_B)\n",
    "hidden2 = keras.layers.Dense(30, activation=\"relu\")(hidden1)\n",
    "concat = keras.layers.concatenate([input_A, hidden2]) # concatenate the inputs\n",
    "output = keras.layers.Dense(1, name=\"main_output\")(concat)\n",
    "aux_output = keras.layers.Dense(1, name=\"aux_output\")(hidden2) # aux output for regularization\n",
    "model = keras.models.Model(inputs=[input_A, input_B],\n",
    "                           outputs=[output, aux_output])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss=[\"mse\", \"mse\"], loss_weights=[0.9, 0.1], optimizer=keras.optimizers.SGD(lr=1e-3)) # compile the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/20\n",
      "11610/11610 [==============================] - 1s 105us/sample - loss: 2.1346 - main_output_loss: 1.9194 - aux_output_loss: 4.0632 - val_loss: 2.9120 - val_main_output_loss: 2.2555 - val_aux_output_loss: 8.8088\n",
      "Epoch 2/20\n",
      "11610/11610 [==============================] - 1s 61us/sample - loss: 0.8954 - main_output_loss: 0.7048 - aux_output_loss: 2.6119 - val_loss: 1.4135 - val_main_output_loss: 0.6348 - val_aux_output_loss: 8.4172\n",
      "Epoch 3/20\n",
      "11610/11610 [==============================] - 1s 65us/sample - loss: 0.7400 - main_output_loss: 0.6077 - aux_output_loss: 1.9305 - val_loss: 1.3594 - val_main_output_loss: 0.5885 - val_aux_output_loss: 8.2925\n",
      "Epoch 4/20\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.6749 - main_output_loss: 0.5690 - aux_output_loss: 1.6264 - val_loss: 1.2789 - val_main_output_loss: 0.5611 - val_aux_output_loss: 7.7340\n",
      "Epoch 5/20\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.6351 - main_output_loss: 0.5420 - aux_output_loss: 1.4729 - val_loss: 1.1841 - val_main_output_loss: 0.5656 - val_aux_output_loss: 6.7464\n",
      "Epoch 6/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.6068 - main_output_loss: 0.5213 - aux_output_loss: 1.3763 - val_loss: 1.0614 - val_main_output_loss: 0.5202 - val_aux_output_loss: 5.9282\n",
      "Epoch 7/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.5832 - main_output_loss: 0.5028 - aux_output_loss: 1.3072 - val_loss: 0.9555 - val_main_output_loss: 0.5111 - val_aux_output_loss: 4.9515\n",
      "Epoch 8/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.5651 - main_output_loss: 0.4892 - aux_output_loss: 1.2463 - val_loss: 0.8426 - val_main_output_loss: 0.4713 - val_aux_output_loss: 4.1805\n",
      "Epoch 9/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.5497 - main_output_loss: 0.4772 - aux_output_loss: 1.2017 - val_loss: 0.7632 - val_main_output_loss: 0.4633 - val_aux_output_loss: 3.4589\n",
      "Epoch 10/20\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.5368 - main_output_loss: 0.4671 - aux_output_loss: 1.1631 - val_loss: 0.6954 - val_main_output_loss: 0.4467 - val_aux_output_loss: 2.9307\n",
      "Epoch 11/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.5257 - main_output_loss: 0.4586 - aux_output_loss: 1.1297 - val_loss: 0.6413 - val_main_output_loss: 0.4292 - val_aux_output_loss: 2.5478\n",
      "Epoch 12/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.5162 - main_output_loss: 0.4516 - aux_output_loss: 1.0989 - val_loss: 0.5950 - val_main_output_loss: 0.4232 - val_aux_output_loss: 2.1396\n",
      "Epoch 13/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.5082 - main_output_loss: 0.4454 - aux_output_loss: 1.0729 - val_loss: 0.5608 - val_main_output_loss: 0.4203 - val_aux_output_loss: 1.8236\n",
      "Epoch 14/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.5022 - main_output_loss: 0.4416 - aux_output_loss: 1.0487 - val_loss: 0.5324 - val_main_output_loss: 0.4142 - val_aux_output_loss: 1.5944\n",
      "Epoch 15/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.4964 - main_output_loss: 0.4376 - aux_output_loss: 1.0240 - val_loss: 0.5206 - val_main_output_loss: 0.4118 - val_aux_output_loss: 1.4985\n",
      "Epoch 16/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.4914 - main_output_loss: 0.4344 - aux_output_loss: 1.0054 - val_loss: 0.4939 - val_main_output_loss: 0.4017 - val_aux_output_loss: 1.3221\n",
      "Epoch 17/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.4865 - main_output_loss: 0.4312 - aux_output_loss: 0.9841 - val_loss: 0.4803 - val_main_output_loss: 0.3993 - val_aux_output_loss: 1.2082\n",
      "Epoch 18/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.4820 - main_output_loss: 0.4281 - aux_output_loss: 0.9663 - val_loss: 0.4820 - val_main_output_loss: 0.4053 - val_aux_output_loss: 1.1710\n",
      "Epoch 19/20\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.4786 - main_output_loss: 0.4264 - aux_output_loss: 0.9490 - val_loss: 0.4661 - val_main_output_loss: 0.3979 - val_aux_output_loss: 1.0790\n",
      "Epoch 20/20\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.4753 - main_output_loss: 0.4245 - aux_output_loss: 0.9320 - val_loss: 0.4598 - val_main_output_loss: 0.3968 - val_aux_output_loss: 1.0257\n"
     ]
    }
   ],
   "source": [
    "history = model.fit([X_train_A, X_train_B], [y_train, y_train], epochs=20,\n",
    "                    validation_data=([X_valid_A, X_valid_B], [y_valid, y_valid])) # fit the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5160/5160 [==============================] - 0s 41us/sample - loss: 5.7750 - main_output_loss: 5.6577 - aux_output_loss: 7.0143\n"
     ]
    }
   ],
   "source": [
    "total_loss, main_loss, aux_loss = model.evaluate(\n",
    "    [X_test_A, X_test_B], [y_test, y_test])\n",
    "y_pred_main, y_pred_aux = model.predict([X_new_A, X_new_B]) # predicting using aux layer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The subclassing API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the WideAndDeepModel using subclassing\n",
    "\n",
    "class WideAndDeepModel(keras.models.Model):\n",
    "    def __init__(self, units=30, activation=\"relu\", **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "        self.hidden1 = keras.layers.Dense(units, activation=activation)\n",
    "        self.hidden2 = keras.layers.Dense(units, activation=activation)\n",
    "        self.main_output = keras.layers.Dense(1)\n",
    "        self.aux_output = keras.layers.Dense(1)\n",
    "        \n",
    "    def call(self, inputs):\n",
    "        input_A, input_B = inputs\n",
    "        hidden1 = self.hidden1(input_B)\n",
    "        hidden2 = self.hidden2(hidden1)\n",
    "        concat = keras.layers.concatenate([input_A, hidden2])\n",
    "        main_output = self.main_output(concat)\n",
    "        aux_output = self.aux_output(hidden2)\n",
    "        return main_output, aux_output\n",
    "\n",
    "model = WideAndDeepModel(30, activation=\"relu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/10\n",
      "11610/11610 [==============================] - 1s 113us/sample - loss: 2.2719 - output_1_loss: 2.1554 - output_2_loss: 3.3117 - val_loss: 4.3377 - val_output_1_loss: 2.7732 - val_output_2_loss: 18.3999\n",
      "Epoch 2/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.9891 - output_1_loss: 0.8653 - output_2_loss: 2.1062 - val_loss: 2.0073 - val_output_1_loss: 0.7581 - val_output_2_loss: 13.2427\n",
      "Epoch 3/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.8320 - output_1_loss: 0.7303 - output_2_loss: 1.7468 - val_loss: 1.7215 - val_output_1_loss: 0.7114 - val_output_2_loss: 10.8051\n",
      "Epoch 4/10\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.7658 - output_1_loss: 0.6760 - output_2_loss: 1.5726 - val_loss: 1.4708 - val_output_1_loss: 0.6454 - val_output_2_loss: 8.8938\n",
      "Epoch 5/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.7223 - output_1_loss: 0.6394 - output_2_loss: 1.4683 - val_loss: 1.3057 - val_output_1_loss: 0.6852 - val_output_2_loss: 6.8846\n",
      "Epoch 6/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.6909 - output_1_loss: 0.6132 - output_2_loss: 1.3901 - val_loss: 1.1005 - val_output_1_loss: 0.5915 - val_output_2_loss: 5.6773\n",
      "Epoch 7/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.6636 - output_1_loss: 0.5894 - output_2_loss: 1.3330 - val_loss: 0.9605 - val_output_1_loss: 0.5611 - val_output_2_loss: 4.5516\n",
      "Epoch 8/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.6406 - output_1_loss: 0.5691 - output_2_loss: 1.2833 - val_loss: 0.8480 - val_output_1_loss: 0.5263 - val_output_2_loss: 3.7399\n",
      "Epoch 9/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.6199 - output_1_loss: 0.5507 - output_2_loss: 1.2416 - val_loss: 0.7650 - val_output_1_loss: 0.5085 - val_output_2_loss: 3.0718\n",
      "Epoch 10/10\n",
      "11610/11610 [==============================] - 1s 64us/sample - loss: 0.6019 - output_1_loss: 0.5351 - output_2_loss: 1.2026 - val_loss: 0.7004 - val_output_1_loss: 0.4916 - val_output_2_loss: 2.5772\n",
      "5160/5160 [==============================] - 0s 35us/sample - loss: 0.5819 - output_1_loss: 0.5174 - output_2_loss: 1.1749\n"
     ]
    }
   ],
   "source": [
    "# Compiling, evaluating, and predicting the model\n",
    "\n",
    "model.compile(loss=\"mse\", loss_weights=[0.9, 0.1], optimizer=keras.optimizers.SGD(lr=1e-3))\n",
    "history = model.fit((X_train_A, X_train_B), (y_train, y_train), epochs=10,\n",
    "                    validation_data=((X_valid_A, X_valid_B), (y_valid, y_valid)))\n",
    "total_loss, main_loss, aux_loss = model.evaluate((X_test_A, X_test_B), (y_test, y_test))\n",
    "y_pred_main, y_pred_aux = model.predict((X_new_A, X_new_B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = WideAndDeepModel(30, activation=\"relu\") # creating an instance of the WideAndDeepModel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving and Restoring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating a model to demonstrate saving and restoring\n",
    "\n",
    "model = keras.models.Sequential([\n",
    "    keras.layers.Dense(30, activation=\"relu\", input_shape=[8]),\n",
    "    keras.layers.Dense(30, activation=\"relu\"),\n",
    "    keras.layers.Dense(1)\n",
    "])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/10\n",
      "11610/11610 [==============================] - 1s 83us/sample - loss: 1.8423 - val_loss: 5.2165\n",
      "Epoch 2/10\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.6876 - val_loss: 0.7732\n",
      "Epoch 3/10\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.5954 - val_loss: 0.5446\n",
      "Epoch 4/10\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.5553 - val_loss: 0.5425\n",
      "Epoch 5/10\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.5268 - val_loss: 0.5539\n",
      "Epoch 6/10\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.5049 - val_loss: 0.4701\n",
      "Epoch 7/10\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4852 - val_loss: 0.4562\n",
      "Epoch 8/10\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4706 - val_loss: 0.4452\n",
      "Epoch 9/10\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4576 - val_loss: 0.4406\n",
      "Epoch 10/10\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4476 - val_loss: 0.4185\n",
      "5160/5160 [==============================] - 0s 28us/sample - loss: 0.4376\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss=\"mse\", optimizer=keras.optimizers.SGD(lr=1e-3)) # compile the model\n",
    "history = model.fit(X_train, y_train, epochs=10, validation_data=(X_valid, y_valid)) # fit the model\n",
    "mse_test = model.evaluate(X_test, y_test) # evalutate the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"my_keras_model.h5\") # Saving the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TREE\r\n",
      "HEAP\r\n",
      "model_weights\r\n",
      "optimizer_weights\r\n",
      "keras_version\r\n",
      "backend\r\n",
      "model_config\r\n",
      "training_config\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "dense_28\r\n",
      "dense_29\r\n",
      "dense_30\r\n",
      "layer_names\r\n",
      "dense_28dense_29dense_30\r\n",
      "GCOL\r\n",
      "2.2.4-tf\r\n",
      "tensorflow\r\n",
      "{\"class_name\": \"Sequential\", \"config\": {\"name\": \"sequential_3\", \"layers\": [{\"class_name\": \"Dense\", \"config\": {\"name\": \"dense_28\", \"trainable\": true, \"batch_input_shape\": [null, 8], \"dtype\": \"float32\", \"units\": 30, \"activation\": \"relu\", \"use_bias\": true, \"kernel_initializer\": {\"class_name\": \"GlorotUniform\", \"config\": {\"seed\": null}}, \"bias_initializer\": {\"class_name\": \"Zeros\", \"config\": {}}, \"kernel_regularizer\": null, \"bias_regularizer\": null, \"activity_regularizer\": null, \"kernel_constraint\": null, \"bias_constraint\": null}}, {\"class_name\": \"Dense\", \"config\": {\"name\": \"dense_29\", \"trainable\": true, \"dtype\": \"float32\", \"units\": 30, \"activation\": \"relu\", \"use_bias\": true, \"kernel_initializer\": {\"class_name\": \"GlorotUniform\", \"config\": {\"seed\": null}}, \"bias_initializer\": {\"class_name\": \"Zeros\", \"config\": {}}, \"kernel_regularizer\": null, \"bias_regularizer\": null, \"activity_regularizer\": null, \"kernel_constraint\": null, \"bias_constraint\": null}}, {\"class_name\": \"Dense\", \"config\": {\"name\": \"dense_30\", \"trainable\": true, \"dtype\": \"float32\", \"units\": 1, \"activation\": \"linear\", \"use_bias\": true, \"kernel_initializer\": {\"class_name\": \"GlorotUniform\", \"config\": {\"seed\": null}}, \"bias_initializer\": {\"class_name\": \"Zeros\", \"config\": {}}, \"kernel_regularizer\": null, \"bias_regularizer\": null, \"activity_regularizer\": null, \"kernel_constraint\": null, \"bias_constraint\": null}}]}}\r\n",
      "{\"loss\": \"mse\", \"metrics\": [], \"weighted_metrics\": null, \"sample_weight_mode\": null, \"loss_weights\": null, \"optimizer_config\": {\"class_name\": \"SGD\", \"config\": {\"name\": \"SGD\", \"learning_rate\": 0.0010000000474974513, \"decay\": 0.0, \"momentum\": 0.0, \"nesterov\": false}}}\r\n",
      "tensorflow\r\n",
      "2.2.4-tf\r\n",
      "SNOD\r\n",
      "backend\r\n",
      "keras_version\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "dense_28\r\n",
      "SNOD\r\n",
      "weight_names\r\n",
      "dense_28/kernel:0dense_28/bias:0\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "kernel:0\r\n",
      "bias:0\r\n",
      "SNOD\r\n",
      "SNOD\r\n",
      "/>Grv\r\n",
      ";EMk=\r\n",
      "= \tQ\r\n",
      "L/c>a\r\n",
      "=Mxa\r\n",
      ">u\t%\r\n",
      "!;c?\r\n",
      "&h>2d\r\n",
      ">e_~\r\n",
      "kXY>\r\n",
      ">19}\r\n",
      "$wu>\r\n",
      "iv>86s<\r\n",
      "=u9H>\r\n",
      "p=1Pi=K\r\n",
      "F>D5\r\n",
      "|>E!\r\n",
      "30>K\r\n",
      "se`;\r\n",
      "v+?=s\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "dense_29\r\n",
      "weight_names\r\n",
      "dense_29/kernel:0dense_29/bias:0\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "kernel:0\r\n",
      "bias:0\r\n",
      "SNOD\r\n",
      "SNOD\r\n",
      "t>cR\r\n",
      "z>uR\r\n",
      "J>DM\r\n",
      "OWh>N\r\n",
      "=r_P\r\n",
      "5I=w#\r\n",
      "*N>8\r\n",
      "`k>M\r\n",
      ">7c@\r\n",
      "Dn=;\r\n",
      ">yQ/>T?\r\n",
      "1W;>\r\n",
      "Kz=o\r\n",
      "Y>#r\r\n",
      "zK>X\r\n",
      ">vfO=\r\n",
      "0_\t:C\r\n",
      "%J>p\r\n",
      ">]q~>%%&=\r\n",
      "E>qQ;\r\n",
      "6>[8\r\n",
      "`!v=~\r\n",
      "d>dV@\r\n",
      "y`n>z\r\n",
      "a>ioe>\r\n",
      "[2>S\r\n",
      ">b%v>\r\n",
      "=FC!\r\n",
      "<Oj=\r\n",
      "=}Td>\r\n",
      ">,F/>\r\n",
      "Z>T%F>\r\n",
      ">s94\r\n",
      "\\>{<\r\n",
      "taZ>\\p\r\n",
      "#`>k\r\n",
      "O>%SN\r\n",
      "dz>)\r\n",
      "7=`DC>\r\n",
      "d>8\t\r\n",
      "Rv=m\r\n",
      "C\t>d\r\n",
      "2>5E\r\n",
      "^,D>\r\n",
      "=J2h>T_\r\n",
      "'#d<f\r\n",
      "p.=1\r\n",
      ">Du2\r\n",
      "MJv>\r\n",
      "L>SR\r\n",
      "=${>\r\n",
      ">=Jc\r\n",
      ";^#>\r\n",
      "=FjN\r\n",
      "Y> H\r\n",
      "u M;\r\n",
      ",>hau\r\n",
      "v0:>\r\n",
      "=x-[=\r\n",
      "P:\tm^\r\n",
      "G[>O\r\n",
      "SC>L\r\n",
      "X_D=bx\r\n",
      "=NB:<\r\n",
      "=pyY\r\n",
      "P=L\\s\r\n",
      "=|m,\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "dense_30\r\n",
      "weight_names\r\n",
      "dense_30/kernel:0dense_30/bias:0\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "kernel:0\r\n",
      "bias:0\r\n",
      "SNOD\r\n",
      "SNOD\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "weight_names\r\n",
      "SGD/iter:0\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "iter:0\r\n",
      "SNOD\r\n",
      "SNOD\r\n"
     ]
    }
   ],
   "source": [
    "!strings my_keras_model.h5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "model1 = keras.models.load_model(\"my_keras_model.h5\") # Loading the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.551559 ],\n",
       "       [1.6555369],\n",
       "       [3.0014234]], dtype=float32)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict(X_new) # predicting using the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save_weights(\"my_keras_weights.ckpt\") # saving the weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f2fc3f57470>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.load_weights(\"my_keras_weights.ckpt\") # loading the saved weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Callbacks during Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clearing previous session and\n",
    "# generating random seed and setting\n",
    "# the random seed\n",
    "\n",
    "keras.backend.clear_session()\n",
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining the model to demostrate callbacks\n",
    "\n",
    "model = keras.models.Sequential([\n",
    "    keras.layers.Dense(30, activation=\"relu\", input_shape=[8]),\n",
    "    keras.layers.Dense(30, activation=\"relu\"),\n",
    "    keras.layers.Dense(1)\n",
    "])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/10\n",
      "11610/11610 [==============================] - 1s 89us/sample - loss: 1.8423 - val_loss: 5.2165\n",
      "Epoch 2/10\n",
      "11610/11610 [==============================] - 1s 62us/sample - loss: 0.6876 - val_loss: 0.7732\n",
      "Epoch 3/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.5954 - val_loss: 0.5446\n",
      "Epoch 4/10\n",
      "11610/11610 [==============================] - 1s 64us/sample - loss: 0.5553 - val_loss: 0.5425\n",
      "Epoch 5/10\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.5268 - val_loss: 0.5539\n",
      "Epoch 6/10\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.5049 - val_loss: 0.4701\n",
      "Epoch 7/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.4852 - val_loss: 0.4562\n",
      "Epoch 8/10\n",
      "11610/11610 [==============================] - 1s 65us/sample - loss: 0.4706 - val_loss: 0.4452\n",
      "Epoch 9/10\n",
      "11610/11610 [==============================] - 1s 64us/sample - loss: 0.4576 - val_loss: 0.4406\n",
      "Epoch 10/10\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.4476 - val_loss: 0.4185\n",
      "5160/5160 [==============================] - 0s 39us/sample - loss: 0.4376\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss=\"mse\", optimizer=keras.optimizers.SGD(lr=1e-3))\n",
    "checkpoint_cb = keras.callbacks.ModelCheckpoint(\"my_keras_model.h5\", save_best_only=True) # saving the best model checkpoint\n",
    "history = model.fit(X_train, y_train, epochs=10,\n",
    "                    validation_data=(X_valid, y_valid),\n",
    "                    callbacks=[checkpoint_cb]) # using the callback\n",
    "model = keras.models.load_model(\"my_keras_model.h5\") # rollback to best model\n",
    "mse_test = model.evaluate(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_keras_model.h5\r\n"
     ]
    }
   ],
   "source": [
    "!ls my_keras_model.h5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/100\n",
      "11610/11610 [==============================] - 1s 83us/sample - loss: 1.8423 - val_loss: 5.2165\n",
      "Epoch 2/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.6876 - val_loss: 0.7732\n",
      "Epoch 3/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.5954 - val_loss: 0.5446\n",
      "Epoch 4/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.5553 - val_loss: 0.5425\n",
      "Epoch 5/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.5268 - val_loss: 0.5539\n",
      "Epoch 6/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.5049 - val_loss: 0.4701\n",
      "Epoch 7/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4852 - val_loss: 0.4562\n",
      "Epoch 8/100\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4706 - val_loss: 0.4452\n",
      "Epoch 9/100\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4576 - val_loss: 0.4406\n",
      "Epoch 10/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4476 - val_loss: 0.4185\n",
      "Epoch 11/100\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.4388 - val_loss: 0.4285\n",
      "Epoch 12/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.4313 - val_loss: 0.4071\n",
      "Epoch 13/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4252 - val_loss: 0.3998\n",
      "Epoch 14/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.4198 - val_loss: 0.3970\n",
      "Epoch 15/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.4152 - val_loss: 0.4115\n",
      "Epoch 16/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4109 - val_loss: 0.3849\n",
      "Epoch 17/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4073 - val_loss: 0.3862\n",
      "Epoch 18/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.4037 - val_loss: 0.3907\n",
      "Epoch 19/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.4003 - val_loss: 0.3751\n",
      "Epoch 20/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3974 - val_loss: 0.3711\n",
      "Epoch 21/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3945 - val_loss: 0.3733\n",
      "Epoch 22/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3919 - val_loss: 0.3676\n",
      "Epoch 23/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3893 - val_loss: 0.3669\n",
      "Epoch 24/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3869 - val_loss: 0.3614\n",
      "Epoch 25/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3846 - val_loss: 0.3600\n",
      "Epoch 26/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3825 - val_loss: 0.3578\n",
      "Epoch 27/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3802 - val_loss: 0.3676\n",
      "Epoch 28/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3781 - val_loss: 0.3545\n",
      "Epoch 29/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3761 - val_loss: 0.3612\n",
      "Epoch 30/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3742 - val_loss: 0.3555\n",
      "Epoch 31/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3724 - val_loss: 0.3544\n",
      "Epoch 32/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3710 - val_loss: 0.3514\n",
      "Epoch 33/100\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.3695 - val_loss: 0.3565\n",
      "Epoch 34/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3681 - val_loss: 0.3455\n",
      "Epoch 35/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3666 - val_loss: 0.3821\n",
      "Epoch 36/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3656 - val_loss: 0.3431\n",
      "Epoch 37/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3642 - val_loss: 0.3772\n",
      "Epoch 38/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3631 - val_loss: 0.3423\n",
      "Epoch 39/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3617 - val_loss: 0.3853\n",
      "Epoch 40/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3610 - val_loss: 0.3393\n",
      "Epoch 41/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3596 - val_loss: 0.3884\n",
      "Epoch 42/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3588 - val_loss: 0.3372\n",
      "Epoch 43/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3576 - val_loss: 0.3485\n",
      "Epoch 44/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3563 - val_loss: 0.3492\n",
      "Epoch 45/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3558 - val_loss: 0.3485\n",
      "Epoch 46/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3549 - val_loss: 0.3363\n",
      "Epoch 47/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3536 - val_loss: 0.3627\n",
      "Epoch 48/100\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.3533 - val_loss: 0.3329\n",
      "Epoch 49/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3525 - val_loss: 0.3859\n",
      "Epoch 50/100\n",
      "11610/11610 [==============================] - 1s 64us/sample - loss: 0.3517 - val_loss: 0.3325\n",
      "Epoch 51/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3511 - val_loss: 0.3382\n",
      "Epoch 52/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3504 - val_loss: 0.3390\n",
      "Epoch 53/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3497 - val_loss: 0.3589\n",
      "Epoch 54/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3489 - val_loss: 0.3365\n",
      "Epoch 55/100\n",
      "11610/11610 [==============================] - 1s 64us/sample - loss: 0.3483 - val_loss: 0.3300\n",
      "Epoch 56/100\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.3476 - val_loss: 0.3821\n",
      "Epoch 57/100\n",
      "11610/11610 [==============================] - 1s 65us/sample - loss: 0.3473 - val_loss: 0.3275\n",
      "Epoch 58/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3464 - val_loss: 0.3390\n",
      "Epoch 59/100\n",
      "11610/11610 [==============================] - 1s 65us/sample - loss: 0.3458 - val_loss: 0.3259\n",
      "Epoch 60/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3452 - val_loss: 0.3903\n",
      "Epoch 61/100\n",
      "11610/11610 [==============================] - 1s 64us/sample - loss: 0.3453 - val_loss: 0.3250\n",
      "Epoch 62/100\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.3443 - val_loss: 0.3863\n",
      "Epoch 63/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3439 - val_loss: 0.3279\n",
      "Epoch 64/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3435 - val_loss: 0.3531\n",
      "Epoch 65/100\n",
      "11610/11610 [==============================] - 1s 65us/sample - loss: 0.3427 - val_loss: 0.3243\n",
      "Epoch 66/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3424 - val_loss: 0.3735\n",
      "Epoch 67/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3421 - val_loss: 0.3470\n",
      "Epoch 68/100\n",
      "11610/11610 [==============================] - 1s 64us/sample - loss: 0.3415 - val_loss: 0.3224\n",
      "Epoch 69/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3409 - val_loss: 0.3802\n",
      "Epoch 70/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3408 - val_loss: 0.3250\n",
      "Epoch 71/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3399 - val_loss: 0.3799\n",
      "Epoch 72/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3398 - val_loss: 0.3426\n",
      "Epoch 73/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3389 - val_loss: 0.3372\n",
      "5160/5160 [==============================] - 0s 28us/sample - loss: 0.3405\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss=\"mse\", optimizer=keras.optimizers.SGD(lr=1e-3))\n",
    "early_stopping_cb = keras.callbacks.EarlyStopping(patience=5,\n",
    "                                                  restore_best_weights=True) # saving early stopping\n",
    "history = model.fit(X_train, y_train, epochs=100,\n",
    "                    validation_data=(X_valid, y_valid),\n",
    "                    callbacks=[checkpoint_cb, early_stopping_cb]) # using the callback for checkpoint, and early stopping\n",
    "mse_test = model.evaluate(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3870/3870 [==============================] - 0s 28us/sample - loss: 0.3224\n"
     ]
    }
   ],
   "source": [
    "mse_test = model.evaluate(X_valid, y_valid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating custom callback\n",
    "\n",
    "class PrintValTrainRatioCallback(keras.callbacks.Callback):\n",
    "    def on_epoch_end(self, epoch, logs):\n",
    "        print(\"\\n SG :: val/train: {:.2f}\".format(logs[\"val_loss\"] / logs[\"loss\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/5\n",
      "11264/11610 [============================>.] - ETA: 0s - loss: 0.3400\n",
      " SG :: val/train: 0.98\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.3388 - val_loss: 0.3329\n",
      "Epoch 2/5\n",
      "11456/11610 [============================>.] - ETA: 0s - loss: 0.3370\n",
      " SG :: val/train: 1.05\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3383 - val_loss: 0.3545\n",
      "Epoch 3/5\n",
      "11488/11610 [============================>.] - ETA: 0s - loss: 0.3387\n",
      " SG :: val/train: 1.04\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3379 - val_loss: 0.3520\n",
      "Epoch 4/5\n",
      "10432/11610 [=========================>....] - ETA: 0s - loss: 0.3341\n",
      " SG :: val/train: 0.97\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3375 - val_loss: 0.3275\n",
      "Epoch 5/5\n",
      "10432/11610 [=========================>....] - ETA: 0s - loss: 0.3344\n",
      " SG :: val/train: 1.03\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3369 - val_loss: 0.3482\n"
     ]
    }
   ],
   "source": [
    "val_train_ratio_cb = PrintValTrainRatioCallback() # calling the custom callback\n",
    "history = model.fit(X_train, y_train, epochs=5,\n",
    "                    validation_data=(X_valid, y_valid),\n",
    "                    callbacks=[val_train_ratio_cb]) # fitting the model using the custom callback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/100\n",
      "11610/11610 [==============================] - 1s 81us/sample - loss: 0.3283 - val_loss: 0.3610\n",
      "Epoch 2/100\n",
      "11610/11610 [==============================] - 1s 63us/sample - loss: 0.3283 - val_loss: 0.3234\n",
      "Epoch 3/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3277 - val_loss: 0.3588\n",
      "Epoch 4/100\n",
      "11610/11610 [==============================] - 1s 61us/sample - loss: 0.3277 - val_loss: 0.3136\n",
      "Epoch 5/100\n",
      "11610/11610 [==============================] - 1s 55us/sample - loss: 0.3271 - val_loss: 0.3576\n",
      "Epoch 6/100\n",
      "11610/11610 [==============================] - 1s 56us/sample - loss: 0.3271 - val_loss: 0.3270\n",
      "Epoch 7/100\n",
      "11610/11610 [==============================] - 1s 57us/sample - loss: 0.3267 - val_loss: 0.3154\n",
      "Epoch 8/100\n",
      "11610/11610 [==============================] - 1s 58us/sample - loss: 0.3264 - val_loss: 0.3161\n",
      "Epoch 9/100\n",
      "11610/11610 [==============================] - 1s 55us/sample - loss: 0.3258 - val_loss: 0.3403\n",
      "5160/5160 [==============================] - 0s 27us/sample - loss: 0.3289\n"
     ]
    }
   ],
   "source": [
    "# SG - Idempotent code\n",
    "keras.backend.clear_session()\n",
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)\n",
    "\n",
    "path = \"my_keras_model.h5\"\n",
    "ck_file = \"my_keras_model_ch_pt.h5\"\n",
    "if os.path.exists(path):\n",
    "    model = keras.models.load_model(path) # Loading the model\n",
    "    if os.path.exists(ck_file):\n",
    "        model.load_weights(ck_file) # loading the saved weights\n",
    "else:\n",
    "    model = keras.models.Sequential([\n",
    "        keras.layers.Dense(30, activation=\"relu\", input_shape=[8]),\n",
    "        keras.layers.Dense(30, activation=\"relu\"),\n",
    "        keras.layers.Dense(1)\n",
    "    ])\n",
    "    model.compile(loss=\"mse\", optimizer=keras.optimizers.SGD(lr=1e-3)) # compile the model\n",
    "    model.save(\"my_keras_model.h5\") # Saving the model\n",
    "\n",
    "checkpoint_cb = keras.callbacks.ModelCheckpoint(ck_file, save_best_only=True) # saving the best model checkpoint\n",
    "early_stopping_cb = keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True) # saving early stopping\n",
    "\n",
    "history = model.fit(X_train, y_train, epochs=100,\n",
    "                    validation_data=(X_valid, y_valid),\n",
    "                    callbacks=[checkpoint_cb, early_stopping_cb]) # using the callback for checkpoint, and early stopping\n",
    "\n",
    "mse_test = model.evaluate(X_test, y_test)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorBoard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "root_logdir = os.path.join(os.curdir, \"my_logs\") # defining root log directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'./my_logs/run_2020_07_19-15_31_01'"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generate a subdirectory path based on the current date\n",
    "# and time so that it’s different at every run\n",
    "\n",
    "def get_run_logdir():\n",
    "    import time\n",
    "    run_id = time.strftime(\"run_%Y_%m_%d-%H_%M_%S\") \n",
    "    return os.path.join(root_logdir, run_id)\n",
    "\n",
    "run_logdir = get_run_logdir()\n",
    "run_logdir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "events.out.tfevents.1595171885.cxln6.16677.337410.v2\r\n",
      "events.out.tfevents.1595171885.cxln6.profile-empty\r\n",
      "events.out.tfevents.1595172637.cxln6.16677.431624.v2\r\n",
      "plugins\r\n"
     ]
    }
   ],
   "source": [
    "!ls my_logs/run_2020_07_19-15_16_22/train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/sandeepgiri9034/iitr-deep-learning-spl-tf2\r\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "keras.backend.clear_session()\n",
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining the model to demostrate Tensorboard functionality\n",
    "\n",
    "model = keras.models.Sequential([\n",
    "    keras.layers.Dense(30, activation=\"relu\", input_shape=[8]),\n",
    "    keras.layers.Dense(30, activation=\"relu\"),\n",
    "    keras.layers.Dense(1)\n",
    "])    \n",
    "model.compile(loss=\"mse\", optimizer=keras.optimizers.SGD(lr=1e-3)) # compiling the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/30\n",
      "11610/11610 [==============================] - 1s 97us/sample - loss: 1.8423 - val_loss: 5.2165\n",
      "Epoch 2/30\n",
      "11610/11610 [==============================] - 1s 68us/sample - loss: 0.6876 - val_loss: 0.7732\n",
      "Epoch 3/30\n",
      "11610/11610 [==============================] - 1s 68us/sample - loss: 0.5954 - val_loss: 0.5446\n",
      "Epoch 4/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.5553 - val_loss: 0.5425\n",
      "Epoch 5/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.5268 - val_loss: 0.5539\n",
      "Epoch 6/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.5049 - val_loss: 0.4701\n",
      "Epoch 7/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.4852 - val_loss: 0.4562\n",
      "Epoch 8/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.4706 - val_loss: 0.4452\n",
      "Epoch 9/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.4576 - val_loss: 0.4406\n",
      "Epoch 10/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.4476 - val_loss: 0.4185\n",
      "Epoch 11/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.4388 - val_loss: 0.4285\n",
      "Epoch 12/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.4313 - val_loss: 0.4071\n",
      "Epoch 13/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.4252 - val_loss: 0.3998\n",
      "Epoch 14/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.4198 - val_loss: 0.3970\n",
      "Epoch 15/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.4152 - val_loss: 0.4115\n",
      "Epoch 16/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.4109 - val_loss: 0.3849\n",
      "Epoch 17/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.4073 - val_loss: 0.3862\n",
      "Epoch 18/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.4037 - val_loss: 0.3907\n",
      "Epoch 19/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.4003 - val_loss: 0.3751\n",
      "Epoch 20/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.3974 - val_loss: 0.3711\n",
      "Epoch 21/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.3945 - val_loss: 0.3733\n",
      "Epoch 22/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.3919 - val_loss: 0.3676\n",
      "Epoch 23/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.3893 - val_loss: 0.3669\n",
      "Epoch 24/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.3869 - val_loss: 0.3614\n",
      "Epoch 25/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.3846 - val_loss: 0.3600\n",
      "Epoch 26/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.3825 - val_loss: 0.3578\n",
      "Epoch 27/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.3802 - val_loss: 0.3676\n",
      "Epoch 28/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.3781 - val_loss: 0.3545\n",
      "Epoch 29/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.3761 - val_loss: 0.3612\n",
      "Epoch 30/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.3742 - val_loss: 0.3555\n"
     ]
    }
   ],
   "source": [
    "tensorboard_cb = keras.callbacks.TensorBoard(run_logdir) # Using Tensorboard callback\n",
    "history = model.fit(X_train, y_train, epochs=30,\n",
    "                    validation_data=(X_valid, y_valid),\n",
    "                    callbacks=[checkpoint_cb, tensorboard_cb])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To start the TensorBoard server, open a terminal and type below command in terminal\n",
    "\n",
    "```bash\n",
    "/usr/local/anaconda/envs/tensorflow2/bin/tensorboard --logdir=./my_logs --port=4049 --bind_all\n",
    "```\n",
    "\n",
    "If you are getting error that port is already in use, then please use any other port in the range of 4040 to 4140. Once TensorBoard server is started then please go to below url to access it\n",
    "\n",
    "http://your_web_console:your_port_number\n",
    "\n",
    "Replace *your_web_console* with your CloudxLab web console address. Say your console is on f.cloudxlab.com then *your_web_console* will be f.cloudxlab.com. *your_port_number* will be the port on which your TensorBoard server is running. Below is the fully qualified url for accessing your TensorBoard server\n",
    "\n",
    "http://f.cloudxlab.com:4049\n",
    "\n",
    "\n",
    "Once you are done, press Ctrl-C in the terminal window, this will shutdown the TensorBoard server."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'./my_logs/run_2020_07_19-15_43_31'"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run_logdir2 = get_run_logdir()\n",
    "run_logdir2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "keras.backend.clear_session()\n",
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "# running another model to compare\n",
    "\n",
    "model = keras.models.Sequential([\n",
    "    keras.layers.Dense(30, activation=\"relu\", input_shape=[8]),\n",
    "    keras.layers.Dense(30, activation=\"relu\"),\n",
    "    keras.layers.Dense(1)\n",
    "])    \n",
    "model.compile(loss=\"mse\", optimizer=keras.optimizers.SGD(lr=0.05))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 11610 samples, validate on 3870 samples\n",
      "Epoch 1/30\n",
      "11610/11610 [==============================] - 1s 97us/sample - loss: 5.6341 - val_loss: 1.3205\n",
      "Epoch 2/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 1.2704 - val_loss: 1.0757\n",
      "Epoch 3/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.9370 - val_loss: 0.7769\n",
      "Epoch 4/30\n",
      "11610/11610 [==============================] - 1s 68us/sample - loss: 0.8854 - val_loss: 0.8254\n",
      "Epoch 5/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.9501 - val_loss: 0.9415\n",
      "Epoch 6/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.8283 - val_loss: 0.6111\n",
      "Epoch 7/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.8095 - val_loss: 0.7394\n",
      "Epoch 8/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 1.1857 - val_loss: 1.0356\n",
      "Epoch 9/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.8920 - val_loss: 0.6564\n",
      "Epoch 10/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 1.2295 - val_loss: 1.1277\n",
      "Epoch 11/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.8992 - val_loss: 0.6219\n",
      "Epoch 12/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.7697 - val_loss: 0.6959\n",
      "Epoch 13/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.7375 - val_loss: 0.6471\n",
      "Epoch 14/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.9825 - val_loss: 1.0278\n",
      "Epoch 15/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.9653 - val_loss: 0.9092\n",
      "Epoch 16/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.9008 - val_loss: 0.8451\n",
      "Epoch 17/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.7838 - val_loss: 0.5818\n",
      "Epoch 18/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.9960 - val_loss: 1.0598\n",
      "Epoch 19/30\n",
      "11610/11610 [==============================] - 1s 66us/sample - loss: 0.7887 - val_loss: 0.6405\n",
      "Epoch 20/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.5706 - val_loss: 0.5093\n",
      "Epoch 21/30\n",
      "11610/11610 [==============================] - 1s 65us/sample - loss: 0.5192 - val_loss: 0.5457\n",
      "Epoch 22/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.4971 - val_loss: 0.4644\n",
      "Epoch 23/30\n",
      "11610/11610 [==============================] - 1s 67us/sample - loss: 0.4815 - val_loss: 0.4120\n",
      "Epoch 24/30\n",
      "11610/11610 [==============================] - 1s 68us/sample - loss: 0.4678 - val_loss: 0.4853\n",
      "Epoch 25/30\n",
      "11610/11610 [==============================] - 1s 68us/sample - loss: 0.4490 - val_loss: 0.3972\n",
      "Epoch 26/30\n",
      "11610/11610 [==============================] - 1s 72us/sample - loss: 0.4348 - val_loss: 0.4258\n",
      "Epoch 27/30\n",
      "11610/11610 [==============================] - 1s 74us/sample - loss: 0.4377 - val_loss: 0.3829\n",
      "Epoch 28/30\n",
      "11610/11610 [==============================] - 1s 72us/sample - loss: 0.4353 - val_loss: 0.3860\n",
      "Epoch 29/30\n",
      "11610/11610 [==============================] - 1s 73us/sample - loss: 0.4209 - val_loss: 0.3763\n",
      "Epoch 30/30\n",
      "11610/11610 [==============================] - 1s 72us/sample - loss: 0.4441 - val_loss: 0.4186\n"
     ]
    }
   ],
   "source": [
    "tensorboard_cb = keras.callbacks.TensorBoard(run_logdir2) # calling the Tensorboard using the second model\n",
    "history = model.fit(X_train, y_train, epochs=30,\n",
    "                    validation_data=(X_valid, y_valid),\n",
    "                    callbacks=[checkpoint_cb, tensorboard_cb])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how TensorBoard now sees two runs, and you can compare the learning curves."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check out the other available logging options:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function __init__ in module tensorflow.python.keras.callbacks:\n",
      "\n",
      "__init__(self, log_dir='logs', histogram_freq=0, write_graph=True, write_images=False, update_freq='epoch', profile_batch=2, embeddings_freq=0, embeddings_metadata=None, **kwargs)\n",
      "    Initialize self.  See help(type(self)) for accurate signature.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(keras.callbacks.TensorBoard.__init__)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow2",
   "language": "python",
   "name": "tensorflow2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "nav_menu": {
   "height": "264px",
   "width": "369px"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}