10. 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": 1,
   "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": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.00235563, 0.04731416, 0.95033021])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.array([1,2,3])\n",
    "y1 = np.exp(3*y) # 2.3**y\n",
    "y1/sum(y1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(54.598150033144236, 54.73632256000002)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(4), 2.72**4"
   ]
  },
  {
   "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": 4,
   "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": 5,
   "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": 6,
   "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": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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": 8,
     "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": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predicting using our model\n",
    "y_pred = per_clf.predict([[2, 0.5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.array"
   ]
  },
  {
   "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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.6.0'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.6.0'"
      ]
     },
     "execution_count": 6,
     "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": 7,
   "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": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 8,
     "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": 9,
   "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": 14,
   "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": 16,
   "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": 17,
   "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": 18,
   "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": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax(arr):\n",
    "    pos = np.exp(arr)\n",
    "    return pos/np.sum(pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.00000000e+00, 3.17997090e-22, 1.18506486e-27])"
      ]
     },
     "execution_count": 20,
     "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": 78,
   "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(50, activation=\"relu\"),\n",
    "    keras.layers.Dense(20, activation=\"relu\"),\n",
    "    keras.layers.Dense(20, activation=\"relu\"),\n",
    "    keras.layers.Dense(20, activation=\"relu\"),\n",
    "    keras.layers.Dense(10, activation=\"softmax\")\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "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": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<keras.layers.core.Flatten at 0x7f13e9cd8860>,\n",
       " <keras.layers.core.Dense at 0x7f13e9cd8e48>,\n",
       " <keras.layers.core.Dense at 0x7f13e9cd8b38>,\n",
       " <keras.layers.core.Dense at 0x7f13e9c84e48>]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.layers # viewing the layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "235500"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "785*300"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "flatten_2 (Flatten)          (None, 784)               0         \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              (None, 300)               235500    \n",
      "_________________________________________________________________\n",
      "dense_7 (Dense)              (None, 100)               30100     \n",
      "_________________________________________________________________\n",
      "dense_8 (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": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keras.utils.plot_model(model, \"my_fashion_mnist_model.png\", show_shapes=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dense_9'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hidden1 = model.layers[1] # first layer\n",
    "hidden1.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.get_layer(hidden1.name) is hidden1 # checking if the layer is hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "weights, biases = hidden1.get_weights() # getting the weights and biases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.07368587, -0.03158443,  0.07245855, ..., -0.04060331,\n",
       "        -0.05746939,  0.05343366],\n",
       "       [-0.04785441, -0.02080581, -0.00573315, ...,  0.02447896,\n",
       "         0.04943242, -0.04283349],\n",
       "       [-0.04391675, -0.05972073, -0.06588375, ...,  0.01406652,\n",
       "         0.05873813, -0.02120901],\n",
       "       ...,\n",
       "       [ 0.0111417 ,  0.03766344,  0.04026911, ...,  0.02438634,\n",
       "         0.05204217, -0.01635746],\n",
       "       [-0.05569723,  0.0465396 , -0.00463293, ...,  0.04842943,\n",
       "         0.05849531, -0.04709498],\n",
       "       [ 0.07356842, -0.01204146,  0.04683723, ..., -0.02917809,\n",
       "        -0.04941867,  0.05423827]], dtype=float32)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights # checking the weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(784, 300)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weights.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biases # checking the biases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(300,)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biases.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = tf.keras.utils.to_categorical([0, 1, 2, 3, 4,5,6,7,8,9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], dtype=float32)"
      ]
     },
     "execution_count": 42,
     "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": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "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": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(55000, 28, 28)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1718.75"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "55000/32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/30\n",
      "1719/1719 [==============================] - 4s 2ms/step - loss: 0.9812 - accuracy: 0.6541 - val_loss: 0.6055 - val_accuracy: 0.7922\n",
      "Epoch 2/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.5637 - accuracy: 0.7998 - val_loss: 0.5098 - val_accuracy: 0.8240\n",
      "Epoch 3/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.4984 - accuracy: 0.8235 - val_loss: 0.4848 - val_accuracy: 0.8306\n",
      "Epoch 4/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.4543 - accuracy: 0.8399 - val_loss: 0.4369 - val_accuracy: 0.8502\n",
      "Epoch 5/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.4259 - accuracy: 0.8491 - val_loss: 0.4401 - val_accuracy: 0.8434\n",
      "Epoch 6/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.4048 - accuracy: 0.8568 - val_loss: 0.3894 - val_accuracy: 0.8620\n",
      "Epoch 7/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.3856 - accuracy: 0.8624 - val_loss: 0.3972 - val_accuracy: 0.8632\n",
      "Epoch 8/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.3722 - accuracy: 0.8671 - val_loss: 0.3759 - val_accuracy: 0.8692\n",
      "Epoch 9/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.3593 - accuracy: 0.8703 - val_loss: 0.3665 - val_accuracy: 0.8706\n",
      "Epoch 10/30\n",
      "1719/1719 [==============================] - 4s 2ms/step - loss: 0.3495 - accuracy: 0.8735 - val_loss: 0.3786 - val_accuracy: 0.8668\n",
      "Epoch 11/30\n",
      "1719/1719 [==============================] - 4s 2ms/step - loss: 0.3387 - accuracy: 0.8783 - val_loss: 0.3892 - val_accuracy: 0.8640\n",
      "Epoch 12/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.3310 - accuracy: 0.8797 - val_loss: 0.3617 - val_accuracy: 0.8736\n",
      "Epoch 13/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.3244 - accuracy: 0.8814 - val_loss: 0.3467 - val_accuracy: 0.8814\n",
      "Epoch 14/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.3195 - accuracy: 0.8827 - val_loss: 0.3617 - val_accuracy: 0.8658\n",
      "Epoch 15/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.3109 - accuracy: 0.8870 - val_loss: 0.3362 - val_accuracy: 0.8770\n",
      "Epoch 16/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.3048 - accuracy: 0.8882 - val_loss: 0.3335 - val_accuracy: 0.8836\n",
      "Epoch 17/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.3004 - accuracy: 0.8898 - val_loss: 0.3416 - val_accuracy: 0.8816\n",
      "Epoch 18/30\n",
      "1719/1719 [==============================] - 4s 2ms/step - loss: 0.2958 - accuracy: 0.8919 - val_loss: 0.3359 - val_accuracy: 0.8846\n",
      "Epoch 19/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2909 - accuracy: 0.8940 - val_loss: 0.3287 - val_accuracy: 0.8858\n",
      "Epoch 20/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2858 - accuracy: 0.8955 - val_loss: 0.3335 - val_accuracy: 0.8844\n",
      "Epoch 21/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2816 - accuracy: 0.8962 - val_loss: 0.3479 - val_accuracy: 0.8778\n",
      "Epoch 22/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2784 - accuracy: 0.8967 - val_loss: 0.3418 - val_accuracy: 0.8788\n",
      "Epoch 23/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2756 - accuracy: 0.8994 - val_loss: 0.3322 - val_accuracy: 0.8814\n",
      "Epoch 24/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2715 - accuracy: 0.8996 - val_loss: 0.3503 - val_accuracy: 0.8792\n",
      "Epoch 25/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2690 - accuracy: 0.9001 - val_loss: 0.3590 - val_accuracy: 0.8718\n",
      "Epoch 26/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2646 - accuracy: 0.9021 - val_loss: 0.3357 - val_accuracy: 0.8806\n",
      "Epoch 27/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2610 - accuracy: 0.9026 - val_loss: 0.3351 - val_accuracy: 0.8854\n",
      "Epoch 28/30\n",
      "1719/1719 [==============================] - 3s 2ms/step - loss: 0.2571 - accuracy: 0.9056 - val_loss: 0.3278 - val_accuracy: 0.8886\n",
      "Epoch 29/30\n",
      "1719/1719 [==============================] - 4s 2ms/step - loss: 0.2559 - accuracy: 0.9052 - val_loss: 0.3223 - val_accuracy: 0.8860\n",
      "Epoch 30/30\n",
      "1719/1719 [==============================] - 4s 2ms/step - loss: 0.2524 - accuracy: 0.9067 - val_loss: 0.3262 - val_accuracy: 0.8818\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": 76,
   "metadata": {
    "scrolled": true
   },
   "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": 77,
   "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": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 1s 2ms/step - loss: 0.3627 - accuracy: 0.8732\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.3627189099788666, 0.873199999332428]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(X_test, y_test) # Evaluating the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "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": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 1.  ],\n",
       "       [0.  , 0.  , 0.99, 0.  , 0.01, 0.  , 0.  , 0.  , 0.  , 0.  ],\n",
       "       [0.  , 1.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  ]],\n",
       "      dtype=float32)"
      ]
     },
     "execution_count": 84,
     "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": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f13e9a6b6d8>"
      ]
     },
     "execution_count": 88,
     "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": 81,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Sequential' object has no attribute 'predict_classes'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-81-19ca18c65123>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# predicting the class of these 3 elements\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0my_pred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_classes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_new\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Sequential' object has no attribute 'predict_classes'"
     ]
    }
   ],
   "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": 89,
   "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": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((11610, 8), (3870, 8), (5160, 8))"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, X_valid.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42) # generating random see\n",
    "tf.random.set_seed(42) # setting random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(11610, 8)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/anaconda/envs/tensorflow2/lib/python3.6/site-packages/keras/optimizer_v2/optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  \"The `lr` argument is deprecated, use `learning_rate` instead.\")\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 1.6419 - val_loss: 0.8560\n",
      "Epoch 2/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.7047 - val_loss: 0.6531\n",
      "Epoch 3/20\n",
      "363/363 [==============================] - 0s 1ms/step - loss: 0.6345 - val_loss: 0.6099\n",
      "Epoch 4/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.5977 - val_loss: 0.5658\n",
      "Epoch 5/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5706 - val_loss: 0.5355\n",
      "Epoch 6/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5472 - val_loss: 0.5173\n",
      "Epoch 7/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.5288 - val_loss: 0.5081\n",
      "Epoch 8/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5130 - val_loss: 0.4799\n",
      "Epoch 9/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4992 - val_loss: 0.4690\n",
      "Epoch 10/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4875 - val_loss: 0.4656\n",
      "Epoch 11/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4777 - val_loss: 0.4482\n",
      "Epoch 12/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4688 - val_loss: 0.4479\n",
      "Epoch 13/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4615 - val_loss: 0.4296\n",
      "Epoch 14/20\n",
      "363/363 [==============================] - 0s 1ms/step - loss: 0.4547 - val_loss: 0.4233\n",
      "Epoch 15/20\n",
      "363/363 [==============================] - 0s 1ms/step - loss: 0.4488 - val_loss: 0.4176\n",
      "Epoch 16/20\n",
      "363/363 [==============================] - 0s 1ms/step - loss: 0.4435 - val_loss: 0.4123\n",
      "Epoch 17/20\n",
      "363/363 [==============================] - 0s 1ms/step - loss: 0.4389 - val_loss: 0.4071\n",
      "Epoch 18/20\n",
      "363/363 [==============================] - 0s 1ms/step - loss: 0.4347 - val_loss: 0.4037\n",
      "Epoch 19/20\n",
      "363/363 [==============================] - 0s 1ms/step - loss: 0.4306 - val_loss: 0.4000\n",
      "Epoch 20/20\n",
      "363/363 [==============================] - 0s 1ms/step - loss: 0.4273 - val_loss: 0.3969\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "162/162 [==============================] - 0s 909us/step - loss: 0.4212\n"
     ]
    }
   ],
   "source": [
    "\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": 95,
   "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": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8,)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = keras.layers.Dense(30, activation=\"relu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def power_creator(power):\n",
    "    def f1(y):\n",
    "        return math.pow(y, power)\n",
    "    return f1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_cube_func = power_creator(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8000.0"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_cube_func(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "mysq = power_creator(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "900.0"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysq(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.0"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power_creator(4)(2)"
   ]
  },
  {
   "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": 114,
   "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": 115,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_2 (InputLayer)            [(None, 8)]          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "dense_32 (Dense)                (None, 30)           270         input_2[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "dense_33 (Dense)                (None, 30)           930         dense_32[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "concatenate_1 (Concatenate)     (None, 38)           0           input_2[0][0]                    \n",
      "                                                                 dense_33[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "dense_34 (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": 116,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 1.6920 - val_loss: 0.8798\n",
      "Epoch 2/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.6836 - val_loss: 0.6420\n",
      "Epoch 3/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.6265 - val_loss: 0.5891\n",
      "Epoch 4/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5877 - val_loss: 0.5455\n",
      "Epoch 5/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.5566 - val_loss: 0.5409\n",
      "Epoch 6/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.5312 - val_loss: 0.4903\n",
      "Epoch 7/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5108 - val_loss: 0.4728\n",
      "Epoch 8/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4952 - val_loss: 0.5017\n",
      "Epoch 9/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4802 - val_loss: 0.4511\n",
      "Epoch 10/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4685 - val_loss: 0.4330\n",
      "Epoch 11/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4590 - val_loss: 0.4991\n",
      "Epoch 12/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4502 - val_loss: 0.4179\n",
      "Epoch 13/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4433 - val_loss: 0.4409\n",
      "Epoch 14/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4363 - val_loss: 0.4239\n",
      "Epoch 15/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4306 - val_loss: 0.4480\n",
      "Epoch 16/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4253 - val_loss: 0.4113\n",
      "Epoch 17/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.4213 - val_loss: 0.4454\n",
      "Epoch 18/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4168 - val_loss: 0.4537\n",
      "Epoch 19/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4126 - val_loss: 0.4084\n",
      "Epoch 20/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4096 - val_loss: 0.4581\n",
      "162/162 [==============================] - 0s 953us/step - loss: 0.4007\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": 117,
   "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": 118,
   "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": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(11610, 8)"
      ]
     },
     "execution_count": 119,
     "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": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(11610, 8)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((11610, 5), (11610, 6))"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_A.shape, X_train_B.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 2.1094 - val_loss: 1.0289\n",
      "Epoch 2/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.7849 - val_loss: 0.6881\n",
      "Epoch 3/20\n",
      "363/363 [==============================] - 1s 1ms/step - loss: 0.6517 - val_loss: 0.6039\n",
      "Epoch 4/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5965 - val_loss: 0.5446\n",
      "Epoch 5/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5595 - val_loss: 0.5129\n",
      "Epoch 6/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5311 - val_loss: 0.4873\n",
      "Epoch 7/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5084 - val_loss: 0.4673\n",
      "Epoch 8/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4898 - val_loss: 0.4499\n",
      "Epoch 9/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4748 - val_loss: 0.4373\n",
      "Epoch 10/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4641 - val_loss: 0.4269\n",
      "Epoch 11/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4561 - val_loss: 0.4202\n",
      "Epoch 12/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4496 - val_loss: 0.4141\n",
      "Epoch 13/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4443 - val_loss: 0.4102\n",
      "Epoch 14/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4398 - val_loss: 0.4063\n",
      "Epoch 15/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4362 - val_loss: 0.4027\n",
      "Epoch 16/20\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.4332 - val_loss: 0.4012\n",
      "Epoch 17/20\n",
      "363/363 [==============================] - 2s 5ms/step - loss: 0.4306 - val_loss: 0.3977\n",
      "Epoch 18/20\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4282 - val_loss: 0.3951\n",
      "Epoch 19/20\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.4256 - val_loss: 0.3950\n",
      "Epoch 20/20\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.4240 - val_loss: 0.3968\n",
      "162/162 [==============================] - 0s 2ms/step - loss: 0.4183\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": 10,
   "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": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "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",
    "        print(\"Initializing\")\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",
    "        print(\"Called call\")\n",
    "        input_A, input_B = inputs\n",
    "        h1 = self.hidden1(input_B)\n",
    "        h2 = self.hidden2(h1)\n",
    "        concat = keras.layers.concatenate([input_A, h2])\n",
    "        main_output = self.main_output(concat)\n",
    "        aux_output = self.aux_output(h2)\n",
    "        return main_output, aux_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing\n"
     ]
    }
   ],
   "source": [
    "model = WideAndDeepModel(30, activation=\"relu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nModel.fit((X1, X2), (Y1, Y2))\\n1. For every epoch:\\n    1. Forward Pass: Model(X1, X2)-> call(), compute the loss\\n        - go layer by layer in model (Right to left)...\\n            - compute the gradients of weights - model.call()\\n            - compute the new values\\n        - update all the weights\\n'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "Model.fit((X1, X2), (Y1, Y2))\n",
    "1. For every epoch:\n",
    "    1. Forward Pass: Model(X1, X2)-> call(), compute the loss\n",
    "        - go layer by layer in model (Right to left)...\n",
    "            - compute the gradients of weights - model.call()\n",
    "            - compute the new values\n",
    "        - update all the weights\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gradients_w = (model(w+delta, X) - model(w, X))/delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss=(\"mse\", \"mse\"), loss_weights=[0.9, 0.1], optimizer=keras.optimizers.SGD(lr=1e-3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # A list of file to compress.\n",
    "# files = [file1, file2, file3....]\n",
    "\n",
    "# def comp(file):\n",
    "#     return compressed_file\n",
    "\n",
    "# map(comp, files) # Apache spark or python...\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BaseLogger',\n",
       " 'CSVLogger',\n",
       " 'Callback',\n",
       " 'CallbackList',\n",
       " 'EarlyStopping',\n",
       " 'History',\n",
       " 'LambdaCallback',\n",
       " 'LearningRateScheduler',\n",
       " 'ModelCheckpoint',\n",
       " 'ProgbarLogger',\n",
       " 'ReduceLROnPlateau',\n",
       " 'RemoteMonitor',\n",
       " 'TensorBoard',\n",
       " 'TerminateOnNaN',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " '_sys',\n",
       " 'experimental']"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(keras.callbacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "Called call\n",
      "Called call\n",
      "355/363 [============================>.] - ETA: 0s - loss: 3.0264 - output_1_loss: 2.7951 - output_2_loss: 5.1081Called call\n",
      "363/363 [==============================] - 2s 3ms/step - loss: 2.9951 - output_1_loss: 2.7618 - output_2_loss: 5.0951 - val_loss: 2.7250 - val_output_1_loss: 1.0989 - val_output_2_loss: 17.3598\n",
      "Epoch 2/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 1.1837 - output_1_loss: 0.8982 - output_2_loss: 3.7535 - val_loss: 2.5461 - val_output_1_loss: 0.7871 - val_output_2_loss: 18.3770\n",
      "Epoch 3/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.9203 - output_1_loss: 0.7131 - output_2_loss: 2.7850 - val_loss: 2.3741 - val_output_1_loss: 0.6856 - val_output_2_loss: 17.5701\n",
      "Epoch 4/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.8067 - output_1_loss: 0.6444 - output_2_loss: 2.2679 - val_loss: 2.1250 - val_output_1_loss: 0.6245 - val_output_2_loss: 15.6295\n",
      "Epoch 5/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.7404 - output_1_loss: 0.6031 - output_2_loss: 1.9763 - val_loss: 1.8501 - val_output_1_loss: 0.5708 - val_output_2_loss: 13.3633\n",
      "Epoch 6/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.6936 - output_1_loss: 0.5711 - output_2_loss: 1.7962 - val_loss: 1.5911 - val_output_1_loss: 0.5385 - val_output_2_loss: 11.0642\n",
      "Epoch 7/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.6576 - output_1_loss: 0.5449 - output_2_loss: 1.6722 - val_loss: 1.3751 - val_output_1_loss: 0.5159 - val_output_2_loss: 9.1082\n",
      "Epoch 8/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.6282 - output_1_loss: 0.5225 - output_2_loss: 1.5797 - val_loss: 1.1917 - val_output_1_loss: 0.4951 - val_output_2_loss: 7.4615\n",
      "Epoch 9/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.6040 - output_1_loss: 0.5038 - output_2_loss: 1.5062 - val_loss: 1.0350 - val_output_1_loss: 0.4674 - val_output_2_loss: 6.1440\n",
      "Epoch 10/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5836 - output_1_loss: 0.4880 - output_2_loss: 1.4443 - val_loss: 0.9192 - val_output_1_loss: 0.4712 - val_output_2_loss: 4.9511\n"
     ]
    }
   ],
   "source": [
    "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "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": 65,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 1.8866 - val_loss: 0.7126\n",
      "Epoch 2/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.6577 - val_loss: 0.6880\n",
      "Epoch 3/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5934 - val_loss: 0.5803\n",
      "Epoch 4/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5557 - val_loss: 0.5166\n",
      "Epoch 5/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5272 - val_loss: 0.4895\n",
      "Epoch 6/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5033 - val_loss: 0.4951\n",
      "Epoch 7/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4854 - val_loss: 0.4861\n",
      "Epoch 8/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4709 - val_loss: 0.4554\n",
      "Epoch 9/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4578 - val_loss: 0.4413\n",
      "Epoch 10/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4474 - val_loss: 0.4379\n",
      "162/162 [==============================] - 0s 1ms/step - loss: 0.4382\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": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"my_keras_model_oct19.h5\") # Saving the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_keras_model_oct19.h5\r\n"
     ]
    }
   ],
   "source": [
    "!ls my_keras_model_oct19*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_keras_model_oct19.h5: Hierarchical Data Format (version 5) data\r\n"
     ]
    }
   ],
   "source": [
    "!file my_keras_model_oct19*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": false
   },
   "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_47\r\n",
      "dense_48\r\n",
      "dense_49\r\n",
      "layer_names\r\n",
      "GCOL\r\n",
      "2.6.0\r\n",
      "tensorflow\r\n",
      "{\"class_name\": \"Sequential\", \"config\": {\"name\": \"sequential_1\", \"layers\": [{\"class_name\": \"InputLayer\", \"config\": {\"batch_input_shape\": [null, 8], \"dtype\": \"float32\", \"sparse\": false, \"ragged\": false, \"name\": \"dense_47_input\"}}, {\"class_name\": \"Dense\", \"config\": {\"name\": \"dense_47\", \"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_48\", \"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_49\", \"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\": null, \"weighted_metrics\": 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",
      "dense_49\r\n",
      "dense_48\r\n",
      "dense_47\r\n",
      "tensorflow\r\n",
      "2.6.0\r\n",
      "dense_47/bias:0\r\n",
      "dense_47/kernel:0\r\n",
      "dense_48/bias:0\r\n",
      "dense_48/kernel:0\r\n",
      "dense_49/bias:0\r\n",
      "dense_49/kernel:0\r\n",
      "SGD/iter:0\r\n",
      "SNOD\r\n",
      "backend\r\n",
      "keras_version\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "dense_47\r\n",
      "SNOD\r\n",
      "weight_names\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "kernel:0\r\n",
      "bias:0\r\n",
      "SNOD\r\n",
      "SNOD\r\n",
      ".>ihw\r\n",
      ",t>Y\t\r\n",
      "'sb>\r\n",
      "@K@>\r\n",
      "=@.0>\r\n",
      "y<=s\r\n",
      "F>Em\r\n",
      "a>bvC\r\n",
      "6>m\"\r\n",
      "5yM=\r\n",
      "MO>6\r\n",
      ">\tUP>\r\n",
      ";9^!\r\n",
      "=v^z>\r\n",
      "b=R8\r\n",
      "&o=!\r\n",
      "~>_M\r\n",
      "4>YQ\r\n",
      "Y;wi*?k\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "dense_48\r\n",
      "weight_names\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "kernel:0\r\n",
      "bias:0\r\n",
      "SNOD\r\n",
      "SNOD\r\n",
      "c>M1p\r\n",
      "e>*%{>\r\n",
      "I>_[\r\n",
      "?5h>\r\n",
      "=wpP\r\n",
      "Y?L>\r\n",
      "No<>\r\n",
      "uW>9\r\n",
      "#c>W\r\n",
      "=;Ld>x![\r\n",
      "Jm<G\r\n",
      "Zk>/\r\n",
      ">j4@\r\n",
      "My%>z\r\n",
      "=UOL>2\r\n",
      "2~>=\r\n",
      "&=K\",\r\n",
      "6>?r\r\n",
      "-w>t\r\n",
      "%kl>H9\r\n",
      "= 0f>M\"<\r\n",
      "l>~e\r\n",
      "@>)O4>S<9>*=_\r\n",
      ">2u+>$\r\n",
      ":=CO\r\n",
      "=OQj\r\n",
      "Fh=6\r\n",
      "4m/>\r\n",
      "@d>O(\r\n",
      ">\\j/>|!\r\n",
      "M>x1\r\n",
      "&g<D\r\n",
      "sP>]\r\n",
      "\t>i1;>\r\n",
      "h)>R\r\n",
      "^>ha\r\n",
      "=W%4\r\n",
      "=Q9Y\r\n",
      ">u|^\r\n",
      "\t\t>D\r\n",
      "hn=8\r\n",
      "i;DE*=\r\n",
      "Jx2>XT\r\n",
      "vWD>\r\n",
      "Hi4>\r\n",
      "=dX,>tyA>v\r\n",
      "n>W/->\r\n",
      "d`#>\r\n",
      "D{>Y\r\n",
      "oW->>Zu\r\n",
      ">J3`\r\n",
      "v=Wj;=\r\n",
      "9@/a\r\n",
      "[C>$p\r\n",
      "iB'>\r\n",
      "0< U\r\n",
      "E<p2\r\n",
      ">PaA\r\n",
      "=piT>\r\n",
      ">~~8>v\r\n",
      "TREE\r\n",
      "HEAP\r\n",
      "dense_49\r\n",
      "weight_names\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",
      "TREE\r\n",
      "HEAP\r\n",
      "iter:0\r\n",
      "SNOD\r\n",
      "SNOD\r\n"
     ]
    }
   ],
   "source": [
    "!strings my_keras_model_oct19.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": {
    "scrolled": true
   },
   "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": 72,
   "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": 73,
   "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": 74,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 1.8866 - val_loss: 0.7126\n",
      "Epoch 2/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.6577 - val_loss: 0.6880\n",
      "Epoch 3/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5934 - val_loss: 0.5803\n",
      "Epoch 4/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5557 - val_loss: 0.5166\n",
      "Epoch 5/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5272 - val_loss: 0.4895\n",
      "Epoch 6/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.5033 - val_loss: 0.4951\n",
      "Epoch 7/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4854 - val_loss: 0.4861\n",
      "Epoch 8/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4709 - val_loss: 0.4554\n",
      "Epoch 9/10\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.4578 - val_loss: 0.4413\n",
      "Epoch 10/10\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.4474 - val_loss: 0.4379\n",
      "162/162 [==============================] - 0s 1ms/step - loss: 0.4382\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",
    "\n",
    "if file.exists(\"my_keras_model.h5\"):\n",
    "    model = keras.models.load_model(\"my_keras_model.h5\") # rollback to best model\n",
    "    \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",
    "\n",
    "mse_test = model.evaluate(X_test, y_test)\n"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "55 -> 60\n",
    ".01, .02, .03, .04, .04\n",
    "the best was 55\n",
    "it will revert the weights to 55th\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "cb = keras.callbacks.Callback?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cb = keras.callbacks.Callback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cb = keras.callbacks.Callback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyCallback(tf.keras.callbacks.Callback):\n",
    "    def on_train_begin(self, x):\n",
    "        print(\"================== BEGING ==============\")\n",
    "    def on_train_end(self, logs=None):\n",
    "        global training_finished\n",
    "        training_finished = True\n",
    "        print(\"================== THIS IS THE END ==============\")\n",
    "    def on_epoch_end(self, epoch, epoch_logs):\n",
    "        print(f\"GIRI: You are at {epoch}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================== BEGING ==============\n",
      "Epoch 1/5\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3496 - val_loss: 0.3508\n",
      "GIRI: You are at 0\n",
      "Epoch 2/5\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3489 - val_loss: 0.3637\n",
      "GIRI: You are at 1\n",
      "Epoch 3/5\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3484 - val_loss: 0.3464\n",
      "GIRI: You are at 2\n",
      "Epoch 4/5\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3479 - val_loss: 0.3338\n",
      "GIRI: You are at 3\n",
      "Epoch 5/5\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3472 - val_loss: 0.3392\n",
      "GIRI: You are at 4\n",
      "================== THIS IS THE END ==============\n",
      "162/162 [==============================] - 0s 1ms/step - loss: 0.3462\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss=\"mse\", optimizer=keras.optimizers.SGD(lr=1e-3))\n",
    "early_stopping_cb = keras.callbacks.EarlyStopping(patience=5,restore_best_weights=True) # saving early stopping\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=5,\n",
    "                    validation_data=(X_valid, y_valid),\n",
    "                    callbacks=[checkpoint_cb, early_stopping_cb, MyCallback()]) # using the callback for checkpoint, and early stopping\n",
    "mse_test = model.evaluate(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r-- 1 sandeepgiri9034 sandeepgiri9034 23408 Oct 19 04:42 my_keras_model.h5\r\n"
     ]
    }
   ],
   "source": [
    "!ls -la my_keras_model.h5"
   ]
  },
  {
   "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": 103,
   "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": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3465 - val_loss: 0.3489\n",
      "\n",
      " SG :: val/train: 1.01\n",
      "Epoch 2/5\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3460 - val_loss: 0.3630\n",
      "\n",
      " SG :: val/train: 1.05\n",
      "Epoch 3/5\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3455 - val_loss: 0.3440\n",
      "\n",
      " SG :: val/train: 1.00\n",
      "Epoch 4/5\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3451 - val_loss: 0.3311\n",
      "\n",
      " SG :: val/train: 0.96\n",
      "Epoch 5/5\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3444 - val_loss: 0.3378\n",
      "\n",
      " SG :: val/train: 0.98\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": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "#root_logdir = os.curdir + \"/my_logs\"\n",
    "import os\n",
    "root_logdir = os.path.join(os.curdir, \"my_logs\") # defining root log directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'./my_logs/run_2024_10_19-04_53_11'"
      ]
     },
     "execution_count": 117,
     "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": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "events.out.tfevents.1729313394.cxln4.16608.0.v2     plugins\r\n",
      "events.out.tfevents.1729313394.cxln4.profile-empty\r\n"
     ]
    }
   ],
   "source": [
    "!ls my_logs/run_2024_10_19-04_49_04/train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/sandeepgiri9034/PG-Certificate-Course-in-AI-Machine-Learning-and-Data-Science-Batch-1-2024-\r\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "keras.backend.clear_session()\n",
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "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": 123,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3731 - val_loss: 0.3525\n",
      "Epoch 2/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3714 - val_loss: 0.3572\n",
      "Epoch 3/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3700 - val_loss: 0.3500\n",
      "Epoch 4/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3685 - val_loss: 0.3481\n",
      "Epoch 5/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3671 - val_loss: 0.3531\n",
      "Epoch 6/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3658 - val_loss: 0.3532\n",
      "Epoch 7/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3646 - val_loss: 0.3489\n",
      "Epoch 8/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3635 - val_loss: 0.3480\n",
      "Epoch 9/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3624 - val_loss: 0.3563\n",
      "Epoch 10/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3612 - val_loss: 0.3550\n",
      "Epoch 11/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3603 - val_loss: 0.3389\n",
      "Epoch 12/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3592 - val_loss: 0.3742\n",
      "Epoch 13/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3583 - val_loss: 0.3508\n",
      "Epoch 14/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3572 - val_loss: 0.3394\n",
      "Epoch 15/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3562 - val_loss: 0.3635\n",
      "Epoch 16/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3555 - val_loss: 0.3346\n",
      "Epoch 17/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3547 - val_loss: 0.3544\n",
      "Epoch 18/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3539 - val_loss: 0.3427\n",
      "Epoch 19/300\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3529 - val_loss: 0.3379\n",
      "Epoch 20/300\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3524 - val_loss: 0.3847\n",
      "Epoch 21/300\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3517 - val_loss: 0.3447\n",
      "Epoch 22/300\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3508 - val_loss: 0.3889\n",
      "Epoch 23/300\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3505 - val_loss: 0.3315\n",
      "Epoch 24/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3496 - val_loss: 0.3569\n",
      "Epoch 25/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3490 - val_loss: 0.3481\n",
      "Epoch 26/300\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3482 - val_loss: 0.3667\n",
      "Epoch 27/300\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3479 - val_loss: 0.3280\n",
      "Epoch 28/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3472 - val_loss: 0.3613\n",
      "Epoch 29/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3468 - val_loss: 0.3361\n",
      "Epoch 30/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3460 - val_loss: 0.3636\n",
      "Epoch 31/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3455 - val_loss: 0.3302\n",
      "Epoch 32/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3448 - val_loss: 0.3789\n",
      "Epoch 33/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3447 - val_loss: 0.3249\n",
      "Epoch 34/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3439 - val_loss: 0.3325\n",
      "Epoch 35/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3434 - val_loss: 0.3529\n",
      "Epoch 36/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3431 - val_loss: 0.3254\n",
      "Epoch 37/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3425 - val_loss: 0.3524\n",
      "Epoch 38/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3420 - val_loss: 0.3254\n",
      "Epoch 39/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3414 - val_loss: 0.3356\n",
      "Epoch 40/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3410 - val_loss: 0.3271\n",
      "Epoch 41/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3405 - val_loss: 0.3478\n",
      "Epoch 42/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3403 - val_loss: 0.3339\n",
      "Epoch 43/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3394 - val_loss: 0.3635\n",
      "Epoch 44/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3393 - val_loss: 0.3454\n",
      "Epoch 45/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3388 - val_loss: 0.3257\n",
      "Epoch 46/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3381 - val_loss: 0.3370\n",
      "Epoch 47/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3380 - val_loss: 0.3384\n",
      "Epoch 48/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3374 - val_loss: 0.3576\n",
      "Epoch 49/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3372 - val_loss: 0.3199\n",
      "Epoch 50/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3366 - val_loss: 0.3190\n",
      "Epoch 51/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3362 - val_loss: 0.3394\n",
      "Epoch 52/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3359 - val_loss: 0.3218\n",
      "Epoch 53/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3356 - val_loss: 0.4003\n",
      "Epoch 54/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3353 - val_loss: 0.3286\n",
      "Epoch 55/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3350 - val_loss: 0.3620\n",
      "Epoch 56/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3345 - val_loss: 0.3187\n",
      "Epoch 57/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3339 - val_loss: 0.3179\n",
      "Epoch 58/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3336 - val_loss: 0.3788\n",
      "Epoch 59/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3336 - val_loss: 0.3182\n",
      "Epoch 60/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3329 - val_loss: 0.3505\n",
      "Epoch 61/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3324 - val_loss: 0.3299\n",
      "Epoch 62/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3323 - val_loss: 0.3449\n",
      "Epoch 63/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3315 - val_loss: 0.3194\n",
      "Epoch 64/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3316 - val_loss: 0.3163\n",
      "Epoch 65/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3311 - val_loss: 0.3273\n",
      "Epoch 66/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3308 - val_loss: 0.3151\n",
      "Epoch 67/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3302 - val_loss: 0.3537\n",
      "Epoch 68/300\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3301 - val_loss: 0.3171\n",
      "Epoch 69/300\n",
      "363/363 [==============================] - 1s 3ms/step - loss: 0.3298 - val_loss: 0.3297\n",
      "Epoch 70/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3294 - val_loss: 0.3506\n",
      "Epoch 71/300\n",
      "363/363 [==============================] - 1s 2ms/step - loss: 0.3291 - val_loss: 0.3504\n",
      "Epoch 72/300\n",
      "156/363 [===========>..................] - ETA: 0s - loss: 0.3157"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-123-c53e69efda07>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m history = model.fit(X_train, y_train, epochs=300,\n\u001b[1;32m      3\u001b[0m                     \u001b[0mvalidation_data\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_valid\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_valid\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m                     callbacks=[checkpoint_cb, tensorboard_cb])\n\u001b[0m",
      "\u001b[0;32m/usr/local/anaconda/envs/tensorflow2/lib/python3.6/site-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m   1182\u001b[0m                 _r=1):\n\u001b[1;32m   1183\u001b[0m               \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1184\u001b[0;31m               \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1185\u001b[0m               \u001b[0;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1186\u001b[0m                 \u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masync_wait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/anaconda/envs/tensorflow2/lib/python3.6/site-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    883\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    884\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jit_compile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 885\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    886\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    887\u001b[0m       \u001b[0mnew_tracing_count\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/anaconda/envs/tensorflow2/lib/python3.6/site-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    915\u001b[0m       \u001b[0;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    916\u001b[0m       \u001b[0;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 917\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateless_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    918\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    919\u001b[0m       \u001b[0;31m# Release the lock early so that multiple threads can perform the call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/anaconda/envs/tensorflow2/lib/python3.6/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   3038\u001b[0m        filtered_flat_args) = self._maybe_define_function(args, kwargs)\n\u001b[1;32m   3039\u001b[0m     return graph_function._call_flat(\n\u001b[0;32m-> 3040\u001b[0;31m         filtered_flat_args, captured_inputs=graph_function.captured_inputs)  # pylint: disable=protected-access\n\u001b[0m\u001b[1;32m   3041\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3042\u001b[0m   \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/anaconda/envs/tensorflow2/lib/python3.6/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m   1962\u001b[0m       \u001b[0;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1963\u001b[0m       return self._build_call_outputs(self._inference_function.call(\n\u001b[0;32m-> 1964\u001b[0;31m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[0m\u001b[1;32m   1965\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n\u001b[1;32m   1966\u001b[0m         \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/anaconda/envs/tensorflow2/lib/python3.6/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36mcall\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m    594\u001b[0m               \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    595\u001b[0m               \u001b[0mattrs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mattrs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 596\u001b[0;31m               ctx=ctx)\n\u001b[0m\u001b[1;32m    597\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    598\u001b[0m           outputs = execute.execute_with_cancellation(\n",
      "\u001b[0;32m/usr/local/anaconda/envs/tensorflow2/lib/python3.6/site-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     58\u001b[0m     \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     59\u001b[0m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0;32m---> 60\u001b[0;31m                                         inputs, attrs, num_outputs)\n\u001b[0m\u001b[1;32m     61\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "tensorboard_cb = keras.callbacks.TensorBoard(run_logdir) # Using Tensorboard callback\n",
    "history = model.fit(X_train, y_train, epochs=300,\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
}