FYS-STK4155/doc/LectureNotes/_build/jupyter_execute/week45.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "967cdaca",
   "metadata": {
    "editable": true
   },
   "source": [
    "<!-- HTML file automatically generated from DocOnce source (https://github.com/doconce/doconce/)\n",
    "doconce format html week45.do.txt --no_mako -->\n",
    "<!-- dom:TITLE: Week 45,  Recurrent Neural Networks -->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f44e4d0",
   "metadata": {
    "editable": true
   },
   "source": [
    "# Week 45,  Recurrent Neural Networks\n",
    "**Morten Hjorth-Jensen**, Department of Physics, University of Oslo and Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University\n",
    "\n",
    "Date: **November 6-10**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3094316d",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Plan for week 45\n",
    "\n",
    "**Material for the active learning sessions on Tuesday and Wednesday.**\n",
    "\n",
    "  * Discussion of project 2\n",
    "\n",
    "  * [Video of lab session from week 43](https://youtu.be/Ia6wwDLxqtM)\n",
    "\n",
    "  * [Video of lab session from week 44](https://youtu.be/EajWMW__k0I)\n",
    "\n",
    "  * [Video of lab session from week 45](https://youtu.be/tgkj0KAEtZo)\n",
    "\n",
    "  * [See also whiteboard notes from lab session week 44](https://github.com/CompPhysics/MachineLearning/blob/master/doc/HandWrittenNotes/2023/Exercisesweek44.pdf)\n",
    "\n",
    "  \n",
    "\n",
    "**Material for the lecture on Thursday November 9, 2023.**\n",
    "\n",
    "  * Short repetition on Convolutional Neural Networks\n",
    "\n",
    "  * Recurrent  Neural Networks (RNNs)\n",
    "\n",
    "  * Readings and Videos:\n",
    "\n",
    "    * These lecture notes\n",
    "\n",
    "    * [Video of lecture](https://youtu.be/z0x-vgyAZUk)\n",
    "\n",
    "    * [Whiteboard notes](https://github.com/CompPhysics/MachineLearning/blob/master/doc/HandWrittenNotes/2023/NotesNov9.pdf)\n",
    "\n",
    "    * For a more in depth discussion on  neural networks we recommend Goodfellow et al chapter 10. See also chapter 11 and 12 on practicalities and applications    \n",
    "\n",
    "     * Reading suggestions for implementation of RNNs: [Aurelien Geron's chapter 14](https://github.com/CompPhysics/MachineLearning/blob/master/doc/Textbooks/TensorflowML.pdf).\n",
    "\n",
    "    * [Video  on Recurrent Neural Networks from MIT](https://www.youtube.com/watch?v=SEnXr6v2ifU&ab_channel=AlexanderAmini)\n",
    "\n",
    "    * [Video on Deep Learning](https://www.youtube.com/playlist?list=PLZHQObOWTQDNU6R1_67000Dx_ZCJB-3pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46b1e9db",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Material for the lab sessions, additional ways to present classification results and other practicalities"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19315bd5",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Searching for Optimal Regularization Parameters $\\lambda$\n",
    "\n",
    "In project 1, when using Ridge and Lasso regression, we end up\n",
    "searching for the optimal parameter $\\lambda$ which minimizes our\n",
    "selected scores (MSE or $R2$ values for example). The brute force\n",
    "approach, as discussed in the code here for Ridge regression, consists\n",
    "in evaluating the MSE as function of different $\\lambda$ values.\n",
    "Based on these calculations, one tries then to determine the value of the hyperparameter $\\lambda$\n",
    "which results in optimal scores (for example the smallest MSE or an $R2=1$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d03a6f44",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "filenames": {
       "image/png": "/Users/mhjensen/Teaching/MachineLearning/doc/LectureNotes/_build/jupyter_execute/week45_5_0.png"
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import linear_model\n",
    "\n",
    "def MSE(y_data,y_model):\n",
    "    n = np.size(y_model)\n",
    "    return np.sum((y_data-y_model)**2)/n\n",
    "# A seed just to ensure that the random numbers are the same for every run.\n",
    "# Useful for eventual debugging.\n",
    "np.random.seed(2021)\n",
    "\n",
    "n = 100\n",
    "x = np.random.rand(n)\n",
    "y = np.exp(-x**2) + 1.5 * np.exp(-(x-2)**2)+ np.random.randn(n)\n",
    "\n",
    "Maxpolydegree = 5\n",
    "X = np.zeros((n,Maxpolydegree-1))\n",
    "\n",
    "for degree in range(1,Maxpolydegree): #No intercept column\n",
    "    X[:,degree-1] = x**(degree)\n",
    "\n",
    "# We split the data in test and training data\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
    "\n",
    "# Decide which values of lambda to use\n",
    "nlambdas = 500\n",
    "MSERidgePredict = np.zeros(nlambdas)\n",
    "lambdas = np.logspace(-4, 2, nlambdas)\n",
    "for i in range(nlambdas):\n",
    "    lmb = lambdas[i]\n",
    "    RegRidge = linear_model.Ridge(lmb)\n",
    "    RegRidge.fit(X_train,y_train)\n",
    "    ypredictRidge = RegRidge.predict(X_test)\n",
    "    MSERidgePredict[i] = MSE(y_test,ypredictRidge)\n",
    "\n",
    "# Now plot the results\n",
    "plt.figure()\n",
    "plt.plot(np.log10(lambdas), MSERidgePredict, 'g--', label = 'MSE SL Ridge Test')\n",
    "plt.xlabel('log10(lambda)')\n",
    "plt.ylabel('MSE')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6cbd4ca",
   "metadata": {
    "editable": true
   },
   "source": [
    "Here we have performed a rather data greedy calculation as function of the regularization parameter $\\lambda$. There is no resampling here. The latter can easily be added by employing the function **RidgeCV** instead of just calling the **Ridge** function. For **RidgeCV** we need to pass the array of $\\lambda$ values.\n",
    "By inspecting the figure we can in turn determine which is the optimal regularization parameter.\n",
    "This becomes however less functional in the long run."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ea723fc",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Grid Search\n",
    "\n",
    "An alternative is to use the so-called grid search functionality\n",
    "included with the library **Scikit-Learn**, as demonstrated for the same\n",
    "example here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0ebb62df",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GridSearchCV(estimator=Ridge(),\n",
      "             param_grid={'alpha': array([1.00000000e-04, 4.64158883e-04, 2.15443469e-03, 1.00000000e-02,\n",
      "       4.64158883e-02, 2.15443469e-01, 1.00000000e+00, 4.64158883e+00,\n",
      "       2.15443469e+01, 1.00000000e+02])})\n",
      "Best estimated lambda-value: 100.0\n",
      "MSE score: 1.0892144853354966\n",
      "R2 score: -0.0038332550504751595\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "def R2(y_data, y_model):\n",
    "    return 1 - np.sum((y_data - y_model) ** 2) / np.sum((y_data - np.mean(y_data)) ** 2)\n",
    "\n",
    "def MSE(y_data,y_model):\n",
    "    n = np.size(y_model)\n",
    "    return np.sum((y_data-y_model)**2)/n\n",
    "\n",
    "# A seed just to ensure that the random numbers are the same for every run.\n",
    "# Useful for eventual debugging.\n",
    "np.random.seed(2021)\n",
    "\n",
    "n = 100\n",
    "x = np.random.rand(n)\n",
    "y = np.exp(-x**2) + 1.5 * np.exp(-(x-2)**2)+ np.random.randn(n)\n",
    "\n",
    "Maxpolydegree = 5\n",
    "X = np.zeros((n,Maxpolydegree-1))\n",
    "\n",
    "for degree in range(1,Maxpolydegree): #No intercept column\n",
    "    X[:,degree-1] = x**(degree)\n",
    "\n",
    "# We split the data in test and training data\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
    "\n",
    "# Decide which values of lambda to use\n",
    "nlambdas = 10\n",
    "lambdas = np.logspace(-4, 2, nlambdas)\n",
    "# create and fit a ridge regression model, testing each alpha\n",
    "model = Ridge()\n",
    "gridsearch = GridSearchCV(estimator=model, param_grid=dict(alpha=lambdas))\n",
    "gridsearch.fit(X_train, y_train)\n",
    "print(gridsearch)\n",
    "ypredictRidge = gridsearch.predict(X_test)\n",
    "# summarize the results of the grid search\n",
    "print(f\"Best estimated lambda-value: {gridsearch.best_estimator_.alpha}\")\n",
    "print(f\"MSE score: {MSE(y_test,ypredictRidge)}\")\n",
    "print(f\"R2 score: {R2(y_test,ypredictRidge)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fb161e1",
   "metadata": {
    "editable": true
   },
   "source": [
    "By default the grid search function includes cross validation with\n",
    "five folds. The [Scikit-Learn\n",
    "documentation](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV)\n",
    "contains more information on how to set the different parameters.\n",
    "\n",
    "If we take out the random noise, running the above codes results in $\\lambda=0$ yielding the best fit."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bdb137e",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Randomized Grid Search\n",
    "\n",
    "An alternative to the above manual grid set up, is to use a random\n",
    "search where the parameters are tuned from a random distribution\n",
    "(uniform below) for a fixed number of iterations. A model is\n",
    "constructed and evaluated for each combination of chosen parameters.\n",
    "We repeat the previous example but now with a random search.  Note\n",
    "that values of $\\lambda$ are now limited to be within $x\\in\n",
    "[0,1]$. This domain may not be the most relevant one for the specific\n",
    "case under study."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "af61779f",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RandomizedSearchCV(estimator=Ridge(), n_iter=100,\n",
      "                   param_distributions={'alpha': <scipy.stats._distn_infrastructure.rv_frozen object at 0x1646da640>})\n",
      "Best estimated lambda-value: 0.9849967686928113\n",
      "MSE score: 1.0853136633465326\n",
      "R2 score: -0.0002382102844775691\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from scipy.stats import uniform as randuniform\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "\n",
    "\n",
    "def R2(y_data, y_model):\n",
    "    return 1 - np.sum((y_data - y_model) ** 2) / np.sum((y_data - np.mean(y_data)) ** 2)\n",
    "\n",
    "def MSE(y_data,y_model):\n",
    "    n = np.size(y_model)\n",
    "    return np.sum((y_data-y_model)**2)/n\n",
    "\n",
    "# A seed just to ensure that the random numbers are the same for every run.\n",
    "# Useful for eventual debugging.\n",
    "np.random.seed(2021)\n",
    "\n",
    "n = 100\n",
    "x = np.random.rand(n)\n",
    "y = np.exp(-x**2) + 1.5 * np.exp(-(x-2)**2)+ np.random.randn(n)\n",
    "\n",
    "Maxpolydegree = 5\n",
    "X = np.zeros((n,Maxpolydegree-1))\n",
    "\n",
    "for degree in range(1,Maxpolydegree): #No intercept column\n",
    "    X[:,degree-1] = x**(degree)\n",
    "\n",
    "# We split the data in test and training data\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
    "\n",
    "param_grid = {'alpha': randuniform()}\n",
    "# create and fit a ridge regression model, testing each alpha\n",
    "model = Ridge()\n",
    "gridsearch = RandomizedSearchCV(estimator=model, param_distributions=param_grid, n_iter=100)\n",
    "gridsearch.fit(X_train, y_train)\n",
    "print(gridsearch)\n",
    "ypredictRidge = gridsearch.predict(X_test)\n",
    "# summarize the results of the grid search\n",
    "print(f\"Best estimated lambda-value: {gridsearch.best_estimator_.alpha}\")\n",
    "print(f\"MSE score: {MSE(y_test,ypredictRidge)}\")\n",
    "print(f\"R2 score: {R2(y_test,ypredictRidge)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89f07674",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Wisconsin Cancer Data\n",
    "\n",
    "We show here how we can use a simple regression case on the breast\n",
    "cancer data using Logistic regression as our algorithm for\n",
    "classification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "37c8ca05",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(426, 30)\n",
      "(143, 30)\n",
      "Test set accuracy with Logistic Regression: 0.94\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.model_selection import  train_test_split \n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "# Load the data\n",
    "cancer = load_breast_cancer()\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(cancer.data,cancer.target,random_state=0)\n",
    "print(X_train.shape)\n",
    "print(X_test.shape)\n",
    "# Logistic Regression\n",
    "logreg = LogisticRegression(solver='lbfgs')\n",
    "logreg.fit(X_train, y_train)\n",
    "print(\"Test set accuracy with Logistic Regression: {:.2f}\".format(logreg.score(X_test,y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "509bf7a9",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Using the correlation matrix\n",
    "\n",
    "In addition to the above scores, we could also study the covariance (and the correlation matrix).\n",
    "We use **Pandas** to compute the correlation matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e9d06a0c",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x2000 with 30 Axes>"
      ]
     },
     "metadata": {
      "filenames": {
       "image/png": "/Users/mhjensen/Teaching/MachineLearning/doc/LectureNotes/_build/jupyter_execute/week45_15_0.png"
      }
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x800 with 2 Axes>"
      ]
     },
     "metadata": {
      "filenames": {
       "image/png": "/Users/mhjensen/Teaching/MachineLearning/doc/LectureNotes/_build/jupyter_execute/week45_15_1.png"
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.model_selection import  train_test_split \n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "cancer = load_breast_cancer()\n",
    "import pandas as pd\n",
    "# Making a data frame\n",
    "cancerpd = pd.DataFrame(cancer.data, columns=cancer.feature_names)\n",
    "\n",
    "fig, axes = plt.subplots(15,2,figsize=(10,20))\n",
    "malignant = cancer.data[cancer.target == 0]\n",
    "benign = cancer.data[cancer.target == 1]\n",
    "ax = axes.ravel()\n",
    "\n",
    "for i in range(30):\n",
    "    _, bins = np.histogram(cancer.data[:,i], bins =50)\n",
    "    ax[i].hist(malignant[:,i], bins = bins, alpha = 0.5)\n",
    "    ax[i].hist(benign[:,i], bins = bins, alpha = 0.5)\n",
    "    ax[i].set_title(cancer.feature_names[i])\n",
    "    ax[i].set_yticks(())\n",
    "ax[0].set_xlabel(\"Feature magnitude\")\n",
    "ax[0].set_ylabel(\"Frequency\")\n",
    "ax[0].legend([\"Malignant\", \"Benign\"], loc =\"best\")\n",
    "fig.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "import seaborn as sns\n",
    "correlation_matrix = cancerpd.corr().round(1)\n",
    "# use the heatmap function from seaborn to plot the correlation matrix\n",
    "# annot = True to print the values inside the square\n",
    "plt.figure(figsize=(15,8))\n",
    "sns.heatmap(data=correlation_matrix, annot=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab1f9810",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Discussing the correlation data\n",
    "\n",
    "In the above example we note two things. In the first plot we display\n",
    "the overlap of benign and malignant tumors as functions of the various\n",
    "features in the Wisconsing breast cancer data set. We see that for\n",
    "some of the features we can distinguish clearly the benign and\n",
    "malignant cases while for other features we cannot. This can point to\n",
    "us which features may be of greater interest when we wish to classify\n",
    "a benign or not benign tumour.\n",
    "\n",
    "In the second figure we have computed the so-called correlation\n",
    "matrix, which in our case with thirty features becomes a $30\\times 30$\n",
    "matrix.\n",
    "\n",
    "We constructed this matrix using **pandas** via the statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d8a5dabe",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "cancerpd = pd.DataFrame(cancer.data, columns=cancer.feature_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69fd6511",
   "metadata": {
    "editable": true
   },
   "source": [
    "and then"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b74de9e5",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "correlation_matrix = cancerpd.corr().round(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24e267e4",
   "metadata": {
    "editable": true
   },
   "source": [
    "Diagonalizing this matrix we can in turn say something about which\n",
    "features are of relevance and which are not. This leads  us to\n",
    "the classical Principal Component Analysis (PCA) theorem with\n",
    "applications. This will be discussed later this semester ([week 43](https://compphysics.github.io/MachineLearning/doc/pub/week43/html/week43-bs.html))."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77a9c527",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Other ways of presenting a classification problem\n",
    "\n",
    "For a binary classifcation matrix, the so-called **confusion matrix**, is often used. It can also be extended to more catgeories/classes as well.\n",
    "The following quantities are then used\n",
    "1. positive condition number $P$, which represents the number of real positive cases in the data (output one/true etc)\n",
    "\n",
    "2. The condition negative number $N$ which is the number of negative cases (ouput zero/false etc)\n",
    "\n",
    "3. The true positive number $TP$ which represents whether a positive test result has been correctly classified (the application of our trained model on a test data set)\n",
    "\n",
    "4. The true negative $TN$ number which represents whether a negative test has been correctly classified\n",
    "\n",
    "5. The false positive $FP$ number, a so-called type I error which tells us about the fraction of  positive test result which are wrongly classified\n",
    "\n",
    "6. A false negative $FN$ number, a so-called type II error which, should be pretty obvious, indicates if a negative test has been wrongly classified.\n",
    "\n",
    "It is is easy to think in terms of illness. You could think of the above as\n",
    "1. True positive: Sick people correctly identified as sick\n",
    "\n",
    "2. False positive: Healthy people incorrectly identified as sick\n",
    "\n",
    "3. True negative: Healthy people correctly identified as healthy\n",
    "\n",
    "4. False negative: Sick people incorrectly identified as healthy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f6ea3f0",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Combinations of classification results\n",
    "\n",
    "It is common in the literature to define various combinations the above numbers. The most commonly used are\n",
    "\n",
    "**Sensitivity, recall, hit rate, or true positive rate $TPR$. It is the probability of a positive test result, conditioned on the individual truly being positive.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0d324b8",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "{\\displaystyle \\mathrm {TPR} ={\\frac {\\mathrm {TP} }{\\mathrm {P} }}={\\frac {\\mathrm {TP} }{\\mathrm {TP} +\\mathrm {FN} }}=1-\\mathrm {FNR} }\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5593af9",
   "metadata": {
    "editable": true
   },
   "source": [
    "The $TPR$ defines how many correct positive results occur among all positive samples available during the test\n",
    "\n",
    "**Miss rate or false negative rate $FNR$.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e857f89e",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "{\\displaystyle \\mathrm {FNR} ={\\frac {\\mathrm {FN} }{\\mathrm {P} }}={\\frac {\\mathrm {FN} }{\\mathrm {FN} +\\mathrm {TP} }} }\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13dc6da3",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Specificity, selectivity or true negative rate $TNR$. It is the probability of a negative test result, conditioned on the individual truly being negative.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f77aa9a",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "{\\displaystyle \\mathrm {TNR} ={\\frac {\\mathrm {TN} }{\\mathrm {N} }}={\\frac {\\mathrm {TN} }{\\mathrm {TN} +\\mathrm {FP} }}=1-\\mathrm {FPR} }\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c560ddf",
   "metadata": {
    "editable": true
   },
   "source": [
    "with the fall-out false positive rate"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b46686df",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "{\\displaystyle \\mathrm {FPR} ={\\frac {\\mathrm {FP} }{\\mathrm {N} }}={\\frac {\\mathrm {FP} }{\\mathrm {FP} +\\mathrm {TN} }}=1-\\mathrm {TNR} }\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24aec375",
   "metadata": {
    "editable": true
   },
   "source": [
    "The $FPR$ defines how many incorrect positive results occur among\n",
    "all negative samples available during the test."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d288b9d",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Positive and negative prediction values\n",
    "\n",
    "The positive and negative predictive values \n",
    "are the proportions of positive and negative results in statistics and\n",
    "diagnostic tests that are true positive and true negative results,\n",
    "respectively.[1] The PPV and NPV describe the performance of a\n",
    "diagnostic test or other statistical measure. A high result can be\n",
    "interpreted as indicating the accuracy of such a statistic.\n",
    "\n",
    "**Precision or positive predictive value $PPV$.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1663205",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "{\\displaystyle \\mathrm {PPV} ={\\frac {\\mathrm {TP} }{\\mathrm {TP} +\\mathrm {FP} }}=1-\\mathrm {FDR} }\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b34d890c",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Negative predictive value $NPV$.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14e7f314",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "{\\displaystyle \\mathrm {NPV} ={\\frac {\\mathrm {TN} }{\\mathrm {TN} +\\mathrm {FN} }}=1-\\mathrm {FOR} }\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "879bac6b",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Other quantities\n",
    "\n",
    "**False discovery rate $FDR$.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31d2b3b7",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "{\\displaystyle \\mathrm {FDR} ={\\frac {\\mathrm {FP} }{\\mathrm {FP} +\\mathrm {TP} }}=1-\\mathrm {PPV} }\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34fd7537",
   "metadata": {
    "editable": true
   },
   "source": [
    "**False omission rate $FOR$.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bebbe84",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "{\\displaystyle \\mathrm {FOR} ={\\frac {\\mathrm {FN} }{\\mathrm {FN} +\\mathrm {TN} }}=1-\\mathrm {NPV} }\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "690c8d76",
   "metadata": {
    "editable": true
   },
   "source": [
    "## $F_1$ score\n",
    "\n",
    "In statistical analysis of binary classification, the F-score or\n",
    "F-measure is a measure of a test's accuracy. It is calculated from the\n",
    "precision and recall of the test, where the precision is the number of\n",
    "true positive results divided by the number of all positive results,\n",
    "including those not identified correctly, and the recall is the number\n",
    "of true positive results divided by the number of all samples that\n",
    "should have been identified as positive. Precision is also known as\n",
    "positive predictive value, and recall is also known as sensitivity in\n",
    "diagnostic binary classification.\n",
    "\n",
    "The F1 score is the harmonic mean of the precision and recall. It thus\n",
    "symmetrically represents both precision and recall in one metric.  The\n",
    "highest possible value of an F-score is 1.0, indicating perfect\n",
    "precision and recall, and the lowest possible value is 0, if either\n",
    "precision or recall are zero.\n",
    "\n",
    "It is defined as"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12d8a75e",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "{\\displaystyle \\mathrm {F} _{1}=2\\times {\\frac {\\mathrm {PPV} \\times \\mathrm {TPR} }{\\mathrm {PPV} +\\mathrm {TPR} }}={\\frac {2\\mathrm {TP} }{2\\mathrm {TP} +\\mathrm {FP} +\\mathrm {FN} }}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1df29154",
   "metadata": {
    "editable": true
   },
   "source": [
    "## ROC curve\n",
    "\n",
    "A receiver operating characteristic curve, or ROC curve, is a\n",
    "graphical plot that illustrates the performance of a binary classifier\n",
    "model at varying threshold values.\n",
    "\n",
    "The ROC curve is the plot of the true positive rate (TPR) against the false positive rate (FPR) at each threshold setting.\n",
    "\n",
    "To draw a ROC curve, only the true positive rate (TPR) and false\n",
    "positive rate (FPR) are needed (as functions of some classifier\n",
    "parameter). The TPR defines how many correct positive results occur\n",
    "among all positive samples available during the test. FPR, on the\n",
    "other hand, defines how many incorrect positive results occur among\n",
    "all negative samples available during the test.\n",
    "\n",
    "See <https://en.wikipedia.org/wiki/Receiver_operating_characteristic> for more discussions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9083178e",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Cumulative gain curve\n",
    "\n",
    "The cumulative gain curve is a performance evaluation used typically for binary classification problems.\n",
    "It plots the $TPR$ True Positive Rate or Sensitivity (which represents the \n",
    "fraction of examples correctly classified\n",
    "against Predictive Positive Rate, which represents \n",
    "the fraction of positively predicted examples.\n",
    "\n",
    "The examples below show the confusion matrix, the ROC curve and the cumulative gain for the Wisconsin cancer data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7719466",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Other measures in classification studies: Cancer Data  again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bcddf060",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(426, 30)\n",
      "(143, 30)\n",
      "[1.         0.86666667 1.         0.92857143 1.         0.85714286\n",
      " 1.         0.92857143 0.92857143 1.        ]\n",
      "Test set accuracy with Logistic Regression: 0.94\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n",
      "/Users/mhjensen/miniforge3/envs/myenv/lib/python3.9/site-packages/sklearn/linear_model/_logistic.py:814: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {
      "filenames": {
       "image/png": "/Users/mhjensen/Teaching/MachineLearning/doc/LectureNotes/_build/jupyter_execute/week45_44_2.png"
      }
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "filenames": {
       "image/png": "/Users/mhjensen/Teaching/MachineLearning/doc/LectureNotes/_build/jupyter_execute/week45_44_3.png"
      }
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "filenames": {
       "image/png": "/Users/mhjensen/Teaching/MachineLearning/doc/LectureNotes/_build/jupyter_execute/week45_44_4.png"
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.model_selection import  train_test_split \n",
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "# Load the data\n",
    "cancer = load_breast_cancer()\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(cancer.data,cancer.target,random_state=0)\n",
    "print(X_train.shape)\n",
    "print(X_test.shape)\n",
    "# Logistic Regression\n",
    "logreg = LogisticRegression(solver='lbfgs')\n",
    "logreg.fit(X_train, y_train)\n",
    "\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.model_selection import cross_validate\n",
    "#Cross validation\n",
    "accuracy = cross_validate(logreg,X_test,y_test,cv=10)['test_score']\n",
    "print(accuracy)\n",
    "print(\"Test set accuracy with Logistic Regression: {:.2f}\".format(logreg.score(X_test,y_test)))\n",
    "\n",
    "import scikitplot as skplt\n",
    "y_pred = logreg.predict(X_test)\n",
    "skplt.metrics.plot_confusion_matrix(y_test, y_pred, normalize=True)\n",
    "plt.show()\n",
    "y_probas = logreg.predict_proba(X_test)\n",
    "skplt.metrics.plot_roc(y_test, y_probas)\n",
    "plt.show()\n",
    "skplt.metrics.plot_cumulative_gain(y_test, y_probas)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ec55e94",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Material for Lecture Thursday November 9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "690b1a08",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Recurrent neural networks (RNNs): Overarching view\n",
    "\n",
    "Till now our focus has been, including convolutional neural networks\n",
    "as well, on feedforward neural networks. The output or the activations\n",
    "flow only in one direction, from the input layer to the output layer.\n",
    "\n",
    "A recurrent neural network (RNN) looks very much like a feedforward\n",
    "neural network, except that it also has connections pointing\n",
    "backward. \n",
    "\n",
    "RNNs are used to analyze time series data such as stock prices, and\n",
    "tell you when to buy or sell. In autonomous driving systems, they can\n",
    "anticipate car trajectories and help avoid accidents. More generally,\n",
    "they can work on sequences of arbitrary lengths, rather than on\n",
    "fixed-sized inputs like all the nets we have discussed so far. For\n",
    "example, they can take sentences, documents, or audio samples as\n",
    "input, making them extremely useful for natural language processing\n",
    "systems such as automatic translation and speech-to-text."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "825bc136",
   "metadata": {
    "editable": true
   },
   "source": [
    "## A simple example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ce956b33",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metal device set to: Apple M1\n",
      "Model: \"sequential\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Layer (type)                Output Shape              Param #   \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================================================\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " simple_rnn (SimpleRNN)      (None, 32)                1184      \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " dense (Dense)               (None, 8)                 264       \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " dense_1 (Dense)             (None, 1)                 9         \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                                 \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=================================================================\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total params: 1,457\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trainable params: 1,457\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Non-trainable params: 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-21 06:15:36.594141: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 1s - loss: 0.6155 - 1s/epoch - 20ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.4372 - 444ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.4090 - 443ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.4011 - 441ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3967 - 440ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3961 - 439ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3966 - 443ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3936 - 442ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3915 - 444ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3908 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3897 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3897 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3896 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3881 - 445ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3876 - 445ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3861 - 444ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3860 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3831 - 448ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3857 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 20/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3854 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 21/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3856 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 22/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3845 - 448ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 23/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3831 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 24/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3839 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 25/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3827 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 26/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3814 - 448ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 27/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3829 - 445ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 28/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3814 - 444ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 29/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3810 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 30/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3803 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 31/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3805 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 32/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3812 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 33/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3812 - 447ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 34/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3794 - 444ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 35/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3778 - 447ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 36/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3787 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 37/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3802 - 445ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 38/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3758 - 447ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 39/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3795 - 445ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 40/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3788 - 444ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 41/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3701 - 447ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 42/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3802 - 443ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 43/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3770 - 444ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 44/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3758 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 45/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3763 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 46/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3768 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 47/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3745 - 445ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 48/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3773 - 443ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 49/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3753 - 447ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 50/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3747 - 446ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 51/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3750 - 440ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 52/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3740 - 448ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 53/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3767 - 448ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 54/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3745 - 455ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 55/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3750 - 452ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 56/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3730 - 452ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 57/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3728 - 452ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 58/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3736 - 451ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 59/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3727 - 450ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 60/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3732 - 453ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 61/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 - 0s - loss: 0.3705 - 451ms/epoch - 9ms/step\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 62/100\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Input \u001b[0;32mIn [9]\u001b[0m, in \u001b[0;36m<cell line: 53>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     50\u001b[0m model\u001b[38;5;241m.\u001b[39mcompile(loss\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmean_squared_error\u001b[39m\u001b[38;5;124m'\u001b[39m, optimizer\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mrmsprop\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m     51\u001b[0m model\u001b[38;5;241m.\u001b[39msummary()\n\u001b[0;32m---> 53\u001b[0m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrainX\u001b[49m\u001b[43m,\u001b[49m\u001b[43mtrainY\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m16\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     54\u001b[0m trainPredict \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mpredict(trainX)\n\u001b[1;32m     55\u001b[0m testPredict\u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mpredict(testX)\n",
      "File \u001b[0;32m~/miniforge3/envs/myenv/lib/python3.9/site-packages/keras/utils/traceback_utils.py:64\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     62\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m     63\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 64\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     65\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:  \u001b[38;5;66;03m# pylint: disable=broad-except\u001b[39;00m\n\u001b[1;32m     66\u001b[0m   filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n",
      "File \u001b[0;32m~/miniforge3/envs/myenv/lib/python3.9/site-packages/keras/engine/training.py:1384\u001b[0m, in \u001b[0;36mModel.fit\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   1377\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mexperimental\u001b[38;5;241m.\u001b[39mTrace(\n\u001b[1;32m   1378\u001b[0m     \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m   1379\u001b[0m     epoch_num\u001b[38;5;241m=\u001b[39mepoch,\n\u001b[1;32m   1380\u001b[0m     step_num\u001b[38;5;241m=\u001b[39mstep,\n\u001b[1;32m   1381\u001b[0m     batch_size\u001b[38;5;241m=\u001b[39mbatch_size,\n\u001b[1;32m   1382\u001b[0m     _r\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m   1383\u001b[0m   callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m-> 1384\u001b[0m   tmp_logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1385\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m data_handler\u001b[38;5;241m.\u001b[39mshould_sync:\n\u001b[1;32m   1386\u001b[0m     context\u001b[38;5;241m.\u001b[39masync_wait()\n",
      "File \u001b[0;32m~/miniforge3/envs/myenv/lib/python3.9/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    152\u001b[0m   filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n",
      "File \u001b[0;32m~/miniforge3/envs/myenv/lib/python3.9/site-packages/tensorflow/python/eager/def_function.py:915\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    912\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    914\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 915\u001b[0m   result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    917\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m    918\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n",
      "File \u001b[0;32m~/miniforge3/envs/myenv/lib/python3.9/site-packages/tensorflow/python/eager/def_function.py:947\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    944\u001b[0m   \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[1;32m    945\u001b[0m   \u001b[38;5;66;03m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[1;32m    946\u001b[0m   \u001b[38;5;66;03m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[0;32m--> 947\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_stateless_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m    948\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_stateful_fn \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    949\u001b[0m   \u001b[38;5;66;03m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[1;32m    950\u001b[0m   \u001b[38;5;66;03m# in parallel.\u001b[39;00m\n\u001b[1;32m    951\u001b[0m   \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n",
      "File \u001b[0;32m~/miniforge3/envs/myenv/lib/python3.9/site-packages/tensorflow/python/eager/function.py:2956\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   2953\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n\u001b[1;32m   2954\u001b[0m   (graph_function,\n\u001b[1;32m   2955\u001b[0m    filtered_flat_args) \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_maybe_define_function(args, kwargs)\n\u001b[0;32m-> 2956\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgraph_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2957\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfiltered_flat_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgraph_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/miniforge3/envs/myenv/lib/python3.9/site-packages/tensorflow/python/eager/function.py:1853\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m   1849\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m   1850\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m   1851\u001b[0m     \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m   1852\u001b[0m   \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1853\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_build_call_outputs(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   1854\u001b[0m \u001b[43m      \u001b[49m\u001b[43mctx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcancellation_manager\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcancellation_manager\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m   1855\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m   1856\u001b[0m     args,\n\u001b[1;32m   1857\u001b[0m     possible_gradient_type,\n\u001b[1;32m   1858\u001b[0m     executing_eagerly)\n\u001b[1;32m   1859\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n",
      "File \u001b[0;32m~/miniforge3/envs/myenv/lib/python3.9/site-packages/tensorflow/python/eager/function.py:499\u001b[0m, in \u001b[0;36m_EagerDefinedFunction.call\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m    497\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m _InterpolateFunctionError(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m    498\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m cancellation_manager \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 499\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    500\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mstr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msignature\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    501\u001b[0m \u001b[43m        \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_num_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    502\u001b[0m \u001b[43m        \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    503\u001b[0m \u001b[43m        \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    504\u001b[0m \u001b[43m        \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mctx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    505\u001b[0m   \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    506\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m    507\u001b[0m         \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msignature\u001b[38;5;241m.\u001b[39mname),\n\u001b[1;32m    508\u001b[0m         num_outputs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_num_outputs,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    511\u001b[0m         ctx\u001b[38;5;241m=\u001b[39mctx,\n\u001b[1;32m    512\u001b[0m         cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_manager)\n",
      "File \u001b[0;32m~/miniforge3/envs/myenv/lib/python3.9/site-packages/tensorflow/python/eager/execute.py:54\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     52\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m     53\u001b[0m   ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 54\u001b[0m   tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     55\u001b[0m \u001b[43m                                      \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     56\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m     57\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Start importing packages\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import datasets, layers, models\n",
    "from tensorflow.keras.layers import Input\n",
    "from tensorflow.keras.models import Model, Sequential \n",
    "from tensorflow.keras.layers import Dense, SimpleRNN, LSTM, GRU\n",
    "from tensorflow.keras import optimizers     \n",
    "from tensorflow.keras import regularizers           \n",
    "from tensorflow.keras.utils import to_categorical \n",
    "\n",
    "\n",
    "\n",
    "# convert into dataset matrix\n",
    "def convertToMatrix(data, step):\n",
    " X, Y =[], []\n",
    " for i in range(len(data)-step):\n",
    "  d=i+step  \n",
    "  X.append(data[i:d,])\n",
    "  Y.append(data[d,])\n",
    " return np.array(X), np.array(Y)\n",
    "\n",
    "step = 4\n",
    "N = 1000    \n",
    "Tp = 800    \n",
    "\n",
    "t=np.arange(0,N)\n",
    "x=np.sin(0.02*t)+2*np.random.rand(N)\n",
    "df = pd.DataFrame(x)\n",
    "df.head()\n",
    "\n",
    "values=df.values\n",
    "train,test = values[0:Tp,:], values[Tp:N,:]\n",
    "\n",
    "# add step elements into train and test\n",
    "test = np.append(test,np.repeat(test[-1,],step))\n",
    "train = np.append(train,np.repeat(train[-1,],step))\n",
    " \n",
    "trainX,trainY =convertToMatrix(train,step)\n",
    "testX,testY =convertToMatrix(test,step)\n",
    "trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))\n",
    "testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1]))\n",
    "\n",
    "model = Sequential()\n",
    "model.add(SimpleRNN(units=32, input_shape=(1,step), activation=\"relu\"))\n",
    "model.add(Dense(8, activation=\"relu\")) \n",
    "model.add(Dense(1))\n",
    "model.compile(loss='mean_squared_error', optimizer='rmsprop')\n",
    "model.summary()\n",
    "\n",
    "model.fit(trainX,trainY, epochs=100, batch_size=16, verbose=2)\n",
    "trainPredict = model.predict(trainX)\n",
    "testPredict= model.predict(testX)\n",
    "predicted=np.concatenate((trainPredict,testPredict),axis=0)\n",
    "\n",
    "trainScore = model.evaluate(trainX, trainY, verbose=0)\n",
    "print(trainScore)\n",
    "plt.plot(df)\n",
    "plt.plot(predicted)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "002c4d99",
   "metadata": {
    "editable": true
   },
   "source": [
    "### RNNs\n",
    "\n",
    "RNNs are very powerful, because they\n",
    "combine two properties:\n",
    "1. Distributed hidden state that allows them to store a lot of information about the past efficiently.\n",
    "\n",
    "2. Non-linear dynamics that allows them to update their hidden state in complicated ways.\n",
    "\n",
    "With enough neurons and time, RNNs\n",
    "can compute anything that can be\n",
    "computed by your computer!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6572c07f",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Basic layout\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN1.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN1.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbd8e269",
   "metadata": {
    "editable": true
   },
   "source": [
    "### We need to specify the initial activity state of all the hidden and output units\n",
    "\n",
    "1. We could just fix these initial states to have some default value like 0.5.\n",
    "\n",
    "2. But it is better to treat the initial states as learned parameters.\n",
    "\n",
    "3. We learn them in the same way as we learn the weights.\n",
    "\n",
    "* Start off with an initial random guess for the initial states.\n",
    "\n",
    "a. At the end of each training sequence, backpropagate through time all the way to the initial states to get the gradient of the error function with respect to each initial state.\n",
    "\n",
    "b. Adjust the initial states by following the negative gradient."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "919bb09e",
   "metadata": {
    "editable": true
   },
   "source": [
    "### We can specify inputs in several ways\n",
    "\n",
    "1. Specify the initial states of all the units.\n",
    "\n",
    "2. Specify the initial states of a subset of the units.\n",
    "\n",
    "3. Specify the states of the same subset of the units at every time step.\n",
    "\n",
    "This is the natural way to model most sequential data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e3360db",
   "metadata": {
    "editable": true
   },
   "source": [
    "### We can specify targets in several ways\n",
    "\n",
    "1. Specify desired final activities of all the units\n",
    "\n",
    "2. Specify desired activities of all units for the last few steps\n",
    "\n",
    "* Good for learning attractors\n",
    "\n",
    "* It is easy to add in extra error derivatives as we backpropagate.\n",
    "\n",
    "  * Specify the desired activity of a subset of the units.\n",
    "\n",
    "* The other units are input or hidden units. \n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN2.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN2.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN3.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN3.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN4.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN4.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN5.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN5.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f284cbd",
   "metadata": {
    "editable": true
   },
   "source": [
    "### Backpropagation through time\n",
    "\n",
    "We can think of the recurrent net as a layered, feed-forward\n",
    "net with shared weights and then train the feed-forward net\n",
    "with weight constraints.\n",
    "\n",
    "We can also think of this training algorithm in the time domain:\n",
    "1. The forward pass builds up a stack of the activities of all the units at each time step.\n",
    "\n",
    "2. The backward pass peels activities off the stack to compute the error derivatives at each time step.\n",
    "\n",
    "3. After the backward pass we add together the derivatives at all the different times for each weight."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5e9785e",
   "metadata": {
    "editable": true
   },
   "source": [
    "### The backward pass is linear\n",
    "\n",
    "1. There is a big difference between the forward and backward passes.\n",
    "\n",
    "2. In the forward pass we use squashing functions (like the logistic) to prevent the activity vectors from exploding.\n",
    "\n",
    "3. The backward pass, is completely linear. If you double the error derivatives at the final layer, all the error derivatives will double.\n",
    "\n",
    "The forward pass determines the slope of the linear function used for\n",
    "backpropagating through each neuron\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN6.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN6.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN7.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN7.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN8.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN8.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN9.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN9.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN10.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN10.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN11.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN11.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN12.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN12.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50a43c30",
   "metadata": {
    "editable": true
   },
   "source": [
    "## The problem of exploding or vanishing gradients\n",
    "* What happens to the magnitude of the gradients as we backpropagate through many layers?\n",
    "\n",
    "a. If the weights are small, the gradients shrink exponentially.\n",
    "\n",
    "b. If the weights are big the gradients grow exponentially.\n",
    "\n",
    "* Typical feed-forward neural nets can cope with these exponential effects because they only have a few hidden layers.\n",
    "\n",
    "* In an RNN trained on long sequences (e.g. 100 time steps) the gradients can easily explode or vanish.\n",
    "\n",
    "a. We can avoid this by initializing the weights very carefully.\n",
    "\n",
    "* Even with good initial weights, its very hard to detect that the current target output depends on an input from many time-steps ago.\n",
    "\n",
    "RNNs have difficulty dealing with long-range dependencies."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3e0d31b",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Four effective ways to learn an RNN\n",
    "1. Long Short Term Memory Make the RNN out of little modules that are designed to remember values for a long time.\n",
    "\n",
    "2. Hessian Free Optimization: Deal with the vanishing gradients problem by using a fancy optimizer that can detect directions with a tiny gradient but even smaller curvature.\n",
    "\n",
    "3. Echo State Networks: Initialize the input a hidden and hidden-hidden and output-hidden connections very carefully so that the hidden state has a huge reservoir of weakly coupled oscillators which can be selectively driven by the input.\n",
    "\n",
    "  * ESNs only need to learn the hidden-output connections.\n",
    "\n",
    "4. Good initialization with momentum Initialize like in Echo State Networks, but then learn all of the connections using momentum"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1571231",
   "metadata": {
    "editable": true
   },
   "source": [
    "### Long Short Term Memory (LSTM)\n",
    "\n",
    "LSTM uses a memory cell for \n",
    " modeling long-range dependencies and avoid vanishing gradient\n",
    " problems.\n",
    "\n",
    "1. Introduced by Hochreiter and Schmidhuber (1997) who solved the problem of getting an RNN to remember things for a long time (like hundreds of time steps).\n",
    "\n",
    "2. They designed a memory cell using logistic and linear units with multiplicative interactions.\n",
    "\n",
    "3. Information gets into the cell whenever its “write” gate is on.\n",
    "\n",
    "4. The information stays in the cell so long as its **keep** gate is on.\n",
    "\n",
    "5. Information can be read from the cell by turning on its **read** gate."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7886dd3",
   "metadata": {
    "editable": true
   },
   "source": [
    "### Implementing a memory cell in a neural network\n",
    "\n",
    "To preserve information for a long time in\n",
    "the activities of an RNN, we use a circuit\n",
    "that implements an analog memory cell.\n",
    "\n",
    "1. A linear unit that has a self-link with a weight of 1 will maintain its state.\n",
    "\n",
    "2. Information is stored in the cell by activating its write gate.\n",
    "\n",
    "3. Information is retrieved by activating the read gate.\n",
    "\n",
    "4. We can backpropagate through this circuit because logistics are have nice derivatives. \n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN13.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN13.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN14.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN14.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN15.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN15.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN16.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN16.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN17.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN17.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN18.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN18.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN19.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN19.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN20.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN20.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN21.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN21.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "<!-- dom:FIGURE: [figslides/RNN22.png, width=700 frac=0.9] -->\n",
    "<!-- begin figure -->\n",
    "\n",
    "<img src=\"figslides/RNN22.png\" width=\"700\"><p style=\"font-size: 0.9em\"><i>Figure 1: </i></p>\n",
    "<!-- end figure -->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f878b195",
   "metadata": {
    "editable": true
   },
   "source": [
    "## An extrapolation example\n",
    "\n",
    "The following code provides an example of how recurrent neural\n",
    "networks can be used to extrapolate to unknown values of physics data\n",
    "sets.  Specifically, the data sets used in this program come from\n",
    "a quantum mechanical many-body calculation of energies as functions of the number of particles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1889da48",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "\n",
    "# For matrices and calculations\n",
    "import numpy as np\n",
    "# For machine learning (backend for keras)\n",
    "import tensorflow as tf\n",
    "# User-friendly machine learning library\n",
    "# Front end for TensorFlow\n",
    "import tensorflow.keras\n",
    "# Different methods from Keras needed to create an RNN\n",
    "# This is not necessary but it shortened function calls \n",
    "# that need to be used in the code.\n",
    "from tensorflow.keras import datasets, layers, models\n",
    "from tensorflow.keras.layers import Input\n",
    "from tensorflow.keras import regularizers\n",
    "from tensorflow.keras.models import Model, Sequential\n",
    "from tensorflow.keras.layers import Dense, SimpleRNN, LSTM, GRU\n",
    "# For timing the code\n",
    "from timeit import default_timer as timer\n",
    "# For plotting\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# The data set\n",
    "datatype='VaryDimension'\n",
    "X_tot = np.arange(2, 42, 2)\n",
    "y_tot = np.array([-0.03077640549, -0.08336233266, -0.1446729567, -0.2116753732, -0.2830637392, -0.3581341341, -0.436462435, -0.5177783846,\n",
    "\t-0.6019067271, -0.6887363571, -0.7782028952, -0.8702784034, -0.9649652536, -1.062292565, -1.16231451, \n",
    "\t-1.265109911, -1.370782966, -1.479465113, -1.591317992, -1.70653767])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bf3bea4",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Formatting the Data\n",
    "\n",
    "The way the recurrent neural networks are trained in this program\n",
    "differs from how machine learning algorithms are usually trained.\n",
    "Typically a machine learning algorithm is trained by learning the\n",
    "relationship between the x data and the y data.  In this program, the\n",
    "recurrent neural network will be trained to recognize the relationship\n",
    "in a sequence of y values.  This is type of data formatting is\n",
    "typically used time series forcasting, but it can also be used in any\n",
    "extrapolation (time series forecasting is just a specific type of\n",
    "extrapolation along the time axis).  This method of data formatting\n",
    "does not use the x data and assumes that the y data are evenly spaced.\n",
    "\n",
    "For a standard machine learning algorithm, the training data has the\n",
    "form of (x,y) so the machine learning algorithm learns to assiciate a\n",
    "y value with a given x value.  This is useful when the test data has x\n",
    "values within the same range as the training data.  However, for this\n",
    "application, the x values of the test data are outside of the x values\n",
    "of the training data and the traditional method of training a machine\n",
    "learning algorithm does not work as well.  For this reason, the\n",
    "recurrent neural network is trained on sequences of y values of the\n",
    "form ((y1, y2), y3), so that the network is concerned with learning\n",
    "the pattern of the y data and not the relation between the x and y\n",
    "data.  As long as the pattern of y data outside of the training region\n",
    "stays relatively stable compared to what was inside the training\n",
    "region, this method of training can produce accurate extrapolations to\n",
    "y values far removed from the training data set.\n",
    "\n",
    "<!--  -->\n",
    "<!-- The idea behind formatting the data in this way comes from [this resource](https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/) and [this one](https://fairyonice.github.io/Understand-Keras%27s-RNN-behind-the-scenes-with-a-sin-wave-example.html). -->\n",
    "<!--  -->\n",
    "<!-- The following method takes in a y data set and formats it so the \"x data\" are of the form (y1, y2) and the \"y data\" are of the form y3, with extra brackets added in to make the resulting arrays compatable with both Keras and Tensorflow. -->\n",
    "<!--  -->\n",
    "<!-- Note: Using a sequence length of two is not required for time series forecasting so any lenght of sequence could be used (for example instead of ((y1, y2) y3) you could change the length of sequence to be 4 and the resulting data points would have the form ((y1, y2, y3, y4), y5)).  While the following method can be used to create a data set of any sequence length, the remainder of the code expects the length of sequence to be 2.  This is because the data sets are very small and the higher the lenght of the sequence the less resulting data points. -->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6fc9b3dd",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# FORMAT_DATA\n",
    "def format_data(data, length_of_sequence = 2):  \n",
    "    \"\"\"\n",
    "        Inputs:\n",
    "            data(a numpy array): the data that will be the inputs to the recurrent neural\n",
    "                network\n",
    "            length_of_sequence (an int): the number of elements in one iteration of the\n",
    "                sequence patter.  For a function approximator use length_of_sequence = 2.\n",
    "        Returns:\n",
    "            rnn_input (a 3D numpy array): the input data for the recurrent neural network.  Its\n",
    "                dimensions are length of data - length of sequence, length of sequence, \n",
    "                dimnsion of data\n",
    "            rnn_output (a numpy array): the training data for the neural network\n",
    "        Formats data to be used in a recurrent neural network.\n",
    "    \"\"\"\n",
    "\n",
    "    X, Y = [], []\n",
    "    for i in range(len(data)-length_of_sequence):\n",
    "        # Get the next length_of_sequence elements\n",
    "        a = data[i:i+length_of_sequence]\n",
    "        # Get the element that immediately follows that\n",
    "        b = data[i+length_of_sequence]\n",
    "        # Reshape so that each data point is contained in its own array\n",
    "        a = np.reshape (a, (len(a), 1))\n",
    "        X.append(a)\n",
    "        Y.append(b)\n",
    "    rnn_input = np.array(X)\n",
    "    rnn_output = np.array(Y)\n",
    "\n",
    "    return rnn_input, rnn_output\n",
    "\n",
    "\n",
    "# ## Defining the Recurrent Neural Network Using Keras\n",
    "# \n",
    "# The following method defines a simple recurrent neural network in keras consisting of one input layer, one hidden layer, and one output layer.\n",
    "\n",
    "def rnn(length_of_sequences, batch_size = None, stateful = False):\n",
    "    \"\"\"\n",
    "        Inputs:\n",
    "            length_of_sequences (an int): the number of y values in \"x data\".  This is determined\n",
    "                when the data is formatted\n",
    "            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.\n",
    "            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.\n",
    "        Returns:\n",
    "            model (a Keras model): The recurrent neural network that is built and compiled by this\n",
    "                method\n",
    "        Builds and compiles a recurrent neural network with one hidden layer and returns the model.\n",
    "    \"\"\"\n",
    "    # Number of neurons in the input and output layers\n",
    "    in_out_neurons = 1\n",
    "    # Number of neurons in the hidden layer\n",
    "    hidden_neurons = 200\n",
    "    # Define the input layer\n",
    "    inp = Input(batch_shape=(batch_size, \n",
    "                length_of_sequences, \n",
    "                in_out_neurons))  \n",
    "    # Define the hidden layer as a simple RNN layer with a set number of neurons and add it to \n",
    "    # the network immediately after the input layer\n",
    "    rnn = SimpleRNN(hidden_neurons, \n",
    "                    return_sequences=False,\n",
    "                    stateful = stateful,\n",
    "                    name=\"RNN\")(inp)\n",
    "    # Define the output layer as a dense neural network layer (standard neural network layer)\n",
    "    #and add it to the network immediately after the hidden layer.\n",
    "    dens = Dense(in_out_neurons,name=\"dense\")(rnn)\n",
    "    # Create the machine learning model starting with the input layer and ending with the \n",
    "    # output layer\n",
    "    model = Model(inputs=[inp],outputs=[dens])\n",
    "    # Compile the machine learning model using the mean squared error function as the loss \n",
    "    # function and an Adams optimizer.\n",
    "    model.compile(loss=\"mean_squared_error\", optimizer=\"adam\")  \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b02bff4",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Predicting New Points With A Trained Recurrent Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7030f585",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def test_rnn (x1, y_test, plot_min, plot_max):\n",
    "    \"\"\"\n",
    "        Inputs:\n",
    "            x1 (a list or numpy array): The complete x component of the data set\n",
    "            y_test (a list or numpy array): The complete y component of the data set\n",
    "            plot_min (an int or float): the smallest x value used in the training data\n",
    "            plot_max (an int or float): the largest x valye used in the training data\n",
    "        Returns:\n",
    "            None.\n",
    "        Uses a trained recurrent neural network model to predict future points in the \n",
    "        series.  Computes the MSE of the predicted data set from the true data set, saves\n",
    "        the predicted data set to a csv file, and plots the predicted and true data sets w\n",
    "        while also displaying the data range used for training.\n",
    "    \"\"\"\n",
    "    # Add the training data as the first dim points in the predicted data array as these\n",
    "    # are known values.\n",
    "    y_pred = y_test[:dim].tolist()\n",
    "    # Generate the first input to the trained recurrent neural network using the last two \n",
    "    # points of the training data.  Based on how the network was trained this means that it\n",
    "    # will predict the first point in the data set after the training data.  All of the \n",
    "    # brackets are necessary for Tensorflow.\n",
    "    next_input = np.array([[[y_test[dim-2]], [y_test[dim-1]]]])\n",
    "    # Save the very last point in the training data set.  This will be used later.\n",
    "    last = [y_test[dim-1]]\n",
    "\n",
    "    # Iterate until the complete data set is created.\n",
    "    for i in range (dim, len(y_test)):\n",
    "        # Predict the next point in the data set using the previous two points.\n",
    "        next = model.predict(next_input)\n",
    "        # Append just the number of the predicted data set\n",
    "        y_pred.append(next[0][0])\n",
    "        # Create the input that will be used to predict the next data point in the data set.\n",
    "        next_input = np.array([[last, next[0]]], dtype=np.float64)\n",
    "        last = next\n",
    "\n",
    "    # Print the mean squared error between the known data set and the predicted data set.\n",
    "    print('MSE: ', np.square(np.subtract(y_test, y_pred)).mean())\n",
    "    # Save the predicted data set as a csv file for later use\n",
    "    name = datatype + 'Predicted'+str(dim)+'.csv'\n",
    "    np.savetxt(name, y_pred, delimiter=',')\n",
    "    # Plot the known data set and the predicted data set.  The red box represents the region that was used\n",
    "    # for the training data.\n",
    "    fig, ax = plt.subplots()\n",
    "    ax.plot(x1, y_test, label=\"true\", linewidth=3)\n",
    "    ax.plot(x1, y_pred, 'g-.',label=\"predicted\", linewidth=4)\n",
    "    ax.legend()\n",
    "    # Created a red region to represent the points used in the training data.\n",
    "    ax.axvspan(plot_min, plot_max, alpha=0.25, color='red')\n",
    "    plt.show()\n",
    "\n",
    "# Check to make sure the data set is complete\n",
    "assert len(X_tot) == len(y_tot)\n",
    "\n",
    "# This is the number of points that will be used in as the training data\n",
    "dim=12\n",
    "\n",
    "# Separate the training data from the whole data set\n",
    "X_train = X_tot[:dim]\n",
    "y_train = y_tot[:dim]\n",
    "\n",
    "\n",
    "# Generate the training data for the RNN, using a sequence of 2\n",
    "rnn_input, rnn_training = format_data(y_train, 2)\n",
    "\n",
    "\n",
    "# Create a recurrent neural network in Keras and produce a summary of the \n",
    "# machine learning model\n",
    "model = rnn(length_of_sequences = rnn_input.shape[1])\n",
    "model.summary()\n",
    "\n",
    "# Start the timer.  Want to time training+testing\n",
    "start = timer()\n",
    "# Fit the model using the training data genenerated above using 150 training iterations and a 5%\n",
    "# validation split.  Setting verbose to True prints information about each training iteration.\n",
    "hist = model.fit(rnn_input, rnn_training, batch_size=None, epochs=150, \n",
    "                 verbose=True,validation_split=0.05)\n",
    "\n",
    "for label in [\"loss\",\"val_loss\"]:\n",
    "    plt.plot(hist.history[label],label=label)\n",
    "\n",
    "plt.ylabel(\"loss\")\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.title(\"The final validation loss: {}\".format(hist.history[\"val_loss\"][-1]))\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Use the trained neural network to predict more points of the data set\n",
    "test_rnn(X_tot, y_tot, X_tot[0], X_tot[dim-1])\n",
    "# Stop the timer and calculate the total time needed.\n",
    "end = timer()\n",
    "print('Time: ', end-start)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53dc1510",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Other Things to Try\n",
    "\n",
    "Changing the size of the recurrent neural network and its parameters\n",
    "can drastically change the results you get from the model.  The below\n",
    "code takes the simple recurrent neural network from above and adds a\n",
    "second hidden layer, changes the number of neurons in the hidden\n",
    "layer, and explicitly declares the activation function of the hidden\n",
    "layers to be a sigmoid function.  The loss function and optimizer can\n",
    "also be changed but are kept the same as the above network.  These\n",
    "parameters can be tuned to provide the optimal result from the\n",
    "network.  For some ideas on how to improve the performance of a\n",
    "[recurrent neural network](https://danijar.com/tips-for-training-recurrent-neural-networks)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "62aa2c1c",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def rnn_2layers(length_of_sequences, batch_size = None, stateful = False):\n",
    "    \"\"\"\n",
    "        Inputs:\n",
    "            length_of_sequences (an int): the number of y values in \"x data\".  This is determined\n",
    "                when the data is formatted\n",
    "            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.\n",
    "            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.\n",
    "        Returns:\n",
    "            model (a Keras model): The recurrent neural network that is built and compiled by this\n",
    "                method\n",
    "        Builds and compiles a recurrent neural network with two hidden layers and returns the model.\n",
    "    \"\"\"\n",
    "    # Number of neurons in the input and output layers\n",
    "    in_out_neurons = 1\n",
    "    # Number of neurons in the hidden layer, increased from the first network\n",
    "    hidden_neurons = 500\n",
    "    # Define the input layer\n",
    "    inp = Input(batch_shape=(batch_size, \n",
    "                length_of_sequences, \n",
    "                in_out_neurons))  \n",
    "    # Create two hidden layers instead of one hidden layer.  Explicitly set the activation\n",
    "    # function to be the sigmoid function (the default value is hyperbolic tangent)\n",
    "    rnn1 = SimpleRNN(hidden_neurons, \n",
    "                    return_sequences=True,  # This needs to be True if another hidden layer is to follow\n",
    "                    stateful = stateful, activation = 'sigmoid',\n",
    "                    name=\"RNN1\")(inp)\n",
    "    rnn2 = SimpleRNN(hidden_neurons, \n",
    "                    return_sequences=False, activation = 'sigmoid',\n",
    "                    stateful = stateful,\n",
    "                    name=\"RNN2\")(rnn1)\n",
    "    # Define the output layer as a dense neural network layer (standard neural network layer)\n",
    "    #and add it to the network immediately after the hidden layer.\n",
    "    dens = Dense(in_out_neurons,name=\"dense\")(rnn2)\n",
    "    # Create the machine learning model starting with the input layer and ending with the \n",
    "    # output layer\n",
    "    model = Model(inputs=[inp],outputs=[dens])\n",
    "    # Compile the machine learning model using the mean squared error function as the loss \n",
    "    # function and an Adams optimizer.\n",
    "    model.compile(loss=\"mean_squared_error\", optimizer=\"adam\")  \n",
    "    return model\n",
    "\n",
    "# Check to make sure the data set is complete\n",
    "assert len(X_tot) == len(y_tot)\n",
    "\n",
    "# This is the number of points that will be used in as the training data\n",
    "dim=12\n",
    "\n",
    "# Separate the training data from the whole data set\n",
    "X_train = X_tot[:dim]\n",
    "y_train = y_tot[:dim]\n",
    "\n",
    "\n",
    "# Generate the training data for the RNN, using a sequence of 2\n",
    "rnn_input, rnn_training = format_data(y_train, 2)\n",
    "\n",
    "\n",
    "# Create a recurrent neural network in Keras and produce a summary of the \n",
    "# machine learning model\n",
    "model = rnn_2layers(length_of_sequences = 2)\n",
    "model.summary()\n",
    "\n",
    "# Start the timer.  Want to time training+testing\n",
    "start = timer()\n",
    "# Fit the model using the training data genenerated above using 150 training iterations and a 5%\n",
    "# validation split.  Setting verbose to True prints information about each training iteration.\n",
    "hist = model.fit(rnn_input, rnn_training, batch_size=None, epochs=150, \n",
    "                 verbose=True,validation_split=0.05)\n",
    "\n",
    "\n",
    "# This section plots the training loss and the validation loss as a function of training iteration.\n",
    "# This is not required for analyzing the couple cluster data but can help determine if the network is\n",
    "# being overtrained.\n",
    "for label in [\"loss\",\"val_loss\"]:\n",
    "    plt.plot(hist.history[label],label=label)\n",
    "\n",
    "plt.ylabel(\"loss\")\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.title(\"The final validation loss: {}\".format(hist.history[\"val_loss\"][-1]))\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Use the trained neural network to predict more points of the data set\n",
    "test_rnn(X_tot, y_tot, X_tot[0], X_tot[dim-1])\n",
    "# Stop the timer and calculate the total time needed.\n",
    "end = timer()\n",
    "print('Time: ', end-start)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56fb2d92",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Other Types of Recurrent Neural Networks\n",
    "\n",
    "Besides a simple recurrent neural network layer, there are two other\n",
    "commonly used types of recurrent neural network layers: Long Short\n",
    "Term Memory (LSTM) and Gated Recurrent Unit (GRU).  For a short\n",
    "introduction to these layers see <https://medium.com/mindboard/lstm-vs-gru-experimental-comparison-955820c21e8b>\n",
    "and <https://medium.com/mindboard/lstm-vs-gru-experimental-comparison-955820c21e8b>.\n",
    "\n",
    "The first network created below is similar to the previous network,\n",
    "but it replaces the SimpleRNN layers with LSTM layers.  The second\n",
    "network below has two hidden layers made up of GRUs, which are\n",
    "preceeded by two dense (feeddorward) neural network layers.  These\n",
    "dense layers \"preprocess\" the data before it reaches the recurrent\n",
    "layers.  This architecture has been shown to improve the performance\n",
    "of recurrent neural networks (see the link above and also\n",
    "<https://arxiv.org/pdf/1807.02857.pdf>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "145ed525",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def lstm_2layers(length_of_sequences, batch_size = None, stateful = False):\n",
    "    \"\"\"\n",
    "        Inputs:\n",
    "            length_of_sequences (an int): the number of y values in \"x data\".  This is determined\n",
    "                when the data is formatted\n",
    "            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.\n",
    "            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.\n",
    "        Returns:\n",
    "            model (a Keras model): The recurrent neural network that is built and compiled by this\n",
    "                method\n",
    "        Builds and compiles a recurrent neural network with two LSTM hidden layers and returns the model.\n",
    "    \"\"\"\n",
    "    # Number of neurons on the input/output layer and the number of neurons in the hidden layer\n",
    "    in_out_neurons = 1\n",
    "    hidden_neurons = 250\n",
    "    # Input Layer\n",
    "    inp = Input(batch_shape=(batch_size, \n",
    "                length_of_sequences, \n",
    "                in_out_neurons)) \n",
    "    # Hidden layers (in this case they are LSTM layers instead if SimpleRNN layers)\n",
    "    rnn= LSTM(hidden_neurons, \n",
    "                    return_sequences=True,\n",
    "                    stateful = stateful,\n",
    "                    name=\"RNN\", use_bias=True, activation='tanh')(inp)\n",
    "    rnn1 = LSTM(hidden_neurons, \n",
    "                    return_sequences=False,\n",
    "                    stateful = stateful,\n",
    "                    name=\"RNN1\", use_bias=True, activation='tanh')(rnn)\n",
    "    # Output layer\n",
    "    dens = Dense(in_out_neurons,name=\"dense\")(rnn1)\n",
    "    # Define the midel\n",
    "    model = Model(inputs=[inp],outputs=[dens])\n",
    "    # Compile the model\n",
    "    model.compile(loss='mean_squared_error', optimizer='adam')  \n",
    "    # Return the model\n",
    "    return model\n",
    "\n",
    "def dnn2_gru2(length_of_sequences, batch_size = None, stateful = False):\n",
    "    \"\"\"\n",
    "        Inputs:\n",
    "            length_of_sequences (an int): the number of y values in \"x data\".  This is determined\n",
    "                when the data is formatted\n",
    "            batch_size (an int): Default value is None.  See Keras documentation of SimpleRNN.\n",
    "            stateful (a boolean): Default value is False.  See Keras documentation of SimpleRNN.\n",
    "        Returns:\n",
    "            model (a Keras model): The recurrent neural network that is built and compiled by this\n",
    "                method\n",
    "        Builds and compiles a recurrent neural network with four hidden layers (two dense followed by\n",
    "        two GRU layers) and returns the model.\n",
    "    \"\"\"    \n",
    "    # Number of neurons on the input/output layers and hidden layers\n",
    "    in_out_neurons = 1\n",
    "    hidden_neurons = 250\n",
    "    # Input layer\n",
    "    inp = Input(batch_shape=(batch_size, \n",
    "                length_of_sequences, \n",
    "                in_out_neurons)) \n",
    "    # Hidden Dense (feedforward) layers\n",
    "    dnn = Dense(hidden_neurons/2, activation='relu', name='dnn')(inp)\n",
    "    dnn1 = Dense(hidden_neurons/2, activation='relu', name='dnn1')(dnn)\n",
    "    # Hidden GRU layers\n",
    "    rnn1 = GRU(hidden_neurons, \n",
    "                    return_sequences=True,\n",
    "                    stateful = stateful,\n",
    "                    name=\"RNN1\", use_bias=True)(dnn1)\n",
    "    rnn = GRU(hidden_neurons, \n",
    "                    return_sequences=False,\n",
    "                    stateful = stateful,\n",
    "                    name=\"RNN\", use_bias=True)(rnn1)\n",
    "    # Output layer\n",
    "    dens = Dense(in_out_neurons,name=\"dense\")(rnn)\n",
    "    # Define the model\n",
    "    model = Model(inputs=[inp],outputs=[dens])\n",
    "    # Compile the mdoel\n",
    "    model.compile(loss='mean_squared_error', optimizer='adam')  \n",
    "    # Return the model\n",
    "    return model\n",
    "\n",
    "# Check to make sure the data set is complete\n",
    "assert len(X_tot) == len(y_tot)\n",
    "\n",
    "# This is the number of points that will be used in as the training data\n",
    "dim=12\n",
    "\n",
    "# Separate the training data from the whole data set\n",
    "X_train = X_tot[:dim]\n",
    "y_train = y_tot[:dim]\n",
    "\n",
    "\n",
    "# Generate the training data for the RNN, using a sequence of 2\n",
    "rnn_input, rnn_training = format_data(y_train, 2)\n",
    "\n",
    "\n",
    "# Create a recurrent neural network in Keras and produce a summary of the \n",
    "# machine learning model\n",
    "# Change the method name to reflect which network you want to use\n",
    "model = dnn2_gru2(length_of_sequences = 2)\n",
    "model.summary()\n",
    "\n",
    "# Start the timer.  Want to time training+testing\n",
    "start = timer()\n",
    "# Fit the model using the training data genenerated above using 150 training iterations and a 5%\n",
    "# validation split.  Setting verbose to True prints information about each training iteration.\n",
    "hist = model.fit(rnn_input, rnn_training, batch_size=None, epochs=150, \n",
    "                 verbose=True,validation_split=0.05)\n",
    "\n",
    "\n",
    "# This section plots the training loss and the validation loss as a function of training iteration.\n",
    "# This is not required for analyzing the couple cluster data but can help determine if the network is\n",
    "# being overtrained.\n",
    "for label in [\"loss\",\"val_loss\"]:\n",
    "    plt.plot(hist.history[label],label=label)\n",
    "\n",
    "plt.ylabel(\"loss\")\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.title(\"The final validation loss: {}\".format(hist.history[\"val_loss\"][-1]))\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Use the trained neural network to predict more points of the data set\n",
    "test_rnn(X_tot, y_tot, X_tot[0], X_tot[dim-1])\n",
    "# Stop the timer and calculate the total time needed.\n",
    "end = timer()\n",
    "print('Time: ', end-start)\n",
    "\n",
    "\n",
    "# ### Training Recurrent Neural Networks in the Standard Way (i.e. learning the relationship between the X and Y data)\n",
    "# \n",
    "# Finally, comparing the performace of a recurrent neural network using the standard data formatting to the performance of the network with time sequence data formatting shows the benefit of this type of data formatting with extrapolation.\n",
    "\n",
    "# Check to make sure the data set is complete\n",
    "assert len(X_tot) == len(y_tot)\n",
    "\n",
    "# This is the number of points that will be used in as the training data\n",
    "dim=12\n",
    "\n",
    "# Separate the training data from the whole data set\n",
    "X_train = X_tot[:dim]\n",
    "y_train = y_tot[:dim]\n",
    "\n",
    "# Reshape the data for Keras specifications\n",
    "X_train = X_train.reshape((dim, 1))\n",
    "y_train = y_train.reshape((dim, 1))\n",
    "\n",
    "\n",
    "# Create a recurrent neural network in Keras and produce a summary of the \n",
    "# machine learning model\n",
    "# Set the sequence length to 1 for regular data formatting \n",
    "model = rnn(length_of_sequences = 1)\n",
    "model.summary()\n",
    "\n",
    "# Start the timer.  Want to time training+testing\n",
    "start = timer()\n",
    "# Fit the model using the training data genenerated above using 150 training iterations and a 5%\n",
    "# validation split.  Setting verbose to True prints information about each training iteration.\n",
    "hist = model.fit(X_train, y_train, batch_size=None, epochs=150, \n",
    "                 verbose=True,validation_split=0.05)\n",
    "\n",
    "\n",
    "# This section plots the training loss and the validation loss as a function of training iteration.\n",
    "# This is not required for analyzing the couple cluster data but can help determine if the network is\n",
    "# being overtrained.\n",
    "for label in [\"loss\",\"val_loss\"]:\n",
    "    plt.plot(hist.history[label],label=label)\n",
    "\n",
    "plt.ylabel(\"loss\")\n",
    "plt.xlabel(\"epoch\")\n",
    "plt.title(\"The final validation loss: {}\".format(hist.history[\"val_loss\"][-1]))\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Use the trained neural network to predict the remaining data points\n",
    "X_pred = X_tot[dim:]\n",
    "X_pred = X_pred.reshape((len(X_pred), 1))\n",
    "y_model = model.predict(X_pred)\n",
    "y_pred = np.concatenate((y_tot[:dim], y_model.flatten()))\n",
    "\n",
    "# Plot the known data set and the predicted data set.  The red box represents the region that was used\n",
    "# for the training data.\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(X_tot, y_tot, label=\"true\", linewidth=3)\n",
    "ax.plot(X_tot, y_pred, 'g-.',label=\"predicted\", linewidth=4)\n",
    "ax.legend()\n",
    "# Created a red region to represent the points used in the training data.\n",
    "ax.axvspan(X_tot[0], X_tot[dim], alpha=0.25, color='red')\n",
    "plt.show()\n",
    "\n",
    "# Stop the timer and calculate the total time needed.\n",
    "end = timer()\n",
    "print('Time: ', end-start)"
   ]
  }
 ],
 "metadata": {
  "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.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}