benchmark/numpy_12/numpy_12_fixed.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iPfsr2ubz_cf"
   },
   "source": [
    "# Time Series Prediction with LSTM Recurrent Neural Networks in Python with Keras\n",
    "\n",
    "Time series prediction problems are a difficult type of predictive modeling problem.\n",
    "\n",
    "Unlike regression predictive modeling, time series also adds the complexity of a sequence dependence among the input variables.\n",
    "\n",
    "A powerful type of neural network designed to handle sequence dependence is called a recurrent neural network. The Long Short-Term Memory network or LSTM network is a type of recurrent neural network used in deep learning because very large architectures can be successfully trained.\n",
    "\n",
    "In this post, you will discover how to develop LSTM networks in Python using the Keras deep learning library to address a demonstration time-series prediction problem.\n",
    "\n",
    "After completing this tutorial, you will know how to implement and develop LSTM networks for your own time series prediction problems and other more general sequence problems. You will know:\n",
    "\n",
    "*   About the International Airline Passengers time-series prediction problem\n",
    "*   How to develop LSTM networks for regression, window, and time-step-based framing of time series prediction problems\n",
    "*   How to develop and make predictions using LSTM networks that maintain state (memory) across very long sequences\n",
    "\n",
    "In this tutorial, we will develop a number of LSTMs for a standard time series prediction problem. The problem and the chosen configuration for the LSTM networks are for demonstration purposes only; they are not optimized.\n",
    "\n",
    "These examples will show exactly how you can develop your own differently structured LSTM networks for time series predictive modeling problems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OOnkbcFJ0NAZ"
   },
   "source": [
    "\n",
    "# Problem Description\n",
    ">The problem you will look at in this post is the International Airline Passengers prediction problem.\n",
    "\n",
    ">his is a problem where, given a year and a month, the task is to predict the number of international airline passengers in units of 1,000. The data ranges from January 1949 to December 1960, or 12 years, with 144 observations.\n",
    "\n",
    ">[Download the dataset](https://raw.githubusercontent.com/jbrownlee/Datasets/master/airline-passengers.csv) (save as “airline-passengers.csv“).\n",
    "Below is a sample of the first few lines of the file.\n",
    "\n",
    "\n",
    "```\n",
    "\"Month\",\"Passengers\"\n",
    "\"1949-01\",112\n",
    "\"1949-02\",118\n",
    "\"1949-03\",132\n",
    "\"1949-04\",129\n",
    "\"1949-05\",121\n",
    "```\n",
    "\n",
    "\n",
    ">You can load this dataset easily using the Pandas library. You are not interested in the date, given that each observation is separated by the same interval of one month. Therefore, when you load the dataset, you can exclude the first column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:35.122619Z",
     "iopub.status.busy": "2023-11-01T09:59:35.121995Z",
     "iopub.status.idle": "2023-11-01T09:59:35.314001Z",
     "shell.execute_reply": "2023-11-01T09:59:35.312789Z",
     "shell.execute_reply.started": "2023-11-01T09:59:35.122584Z"
    },
    "id": "2NAKmS3oz88y",
    "outputId": "0fe9164a-f15c-472a-fe64-2290786629b7"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas\n",
    "import matplotlib.pyplot as plt\n",
    "dataset = pandas.read_csv('data/international-airline-passengers.csv', usecols=[1], engine='python')\n",
    "plt.plot(dataset)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VUyjZEHo2xhL"
   },
   "source": [
    ">You can see an upward trend in the dataset over time. You can also see some periodicity in the dataset that probably corresponds to the Northern Hemisphere vacation period.\n",
    "\n",
    ">You can phrase the problem as a regression problem. That is, given the number of passengers (in units of thousands) this month, what is the number of passengers next month?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BCYd6kmI3RM8"
   },
   "source": [
    "# Data Preparation and librairies importing\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u8XrVDSL4fwe"
   },
   "source": [
    ">Before you start, let’s first import all the functions and classes you will use. This assumes a working SciPy environment with the Keras deep learning library installed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:35.316457Z",
     "iopub.status.busy": "2023-11-01T09:59:35.316100Z",
     "iopub.status.idle": "2023-11-01T09:59:35.323208Z",
     "shell.execute_reply": "2023-11-01T09:59:35.321365Z",
     "shell.execute_reply.started": "2023-11-01T09:59:35.316427Z"
    },
    "id": "gb2FybxA4cNr"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Dropout\n",
    "from tensorflow.keras.layers import LSTM\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.metrics import mean_squared_error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LVW9qsY24xl3"
   },
   "source": [
    ">LSTMs are sensitive to the scale of the input data, specifically when the sigmoid (default) or tanh activation functions are used. It can be a good practice to rescale the data to the range of 0-to-1, also called normalizing. You can easily normalize the dataset using the MinMaxScaler preprocessing class from the scikit-learn library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:35.325969Z",
     "iopub.status.busy": "2023-11-01T09:59:35.324998Z",
     "iopub.status.idle": "2023-11-01T09:59:35.345026Z",
     "shell.execute_reply": "2023-11-01T09:59:35.343796Z",
     "shell.execute_reply.started": "2023-11-01T09:59:35.325918Z"
    },
    "id": "IVs0D8Fw49yG"
   },
   "outputs": [],
   "source": [
    "# normalize the dataset\n",
    "scaler = MinMaxScaler(feature_range=(0, 1))\n",
    "dataset = scaler.fit_transform(dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "u9J8Jyjx5G5g"
   },
   "source": [
    ">After you model the data and estimate the skill of your model on the training dataset, you need to get an idea of the skill of the model on new unseen data. For a normal classification or regression problem, you would do this using cross validation.\n",
    "\n",
    ">With time series data, the sequence of values is important. A simple method that you can use is to split the ordered dataset into train and test datasets. The code below calculates the index of the split point and separates the data into the training datasets, with 67% of the observations used to train the model, leaving the remaining 33% for testing the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:35.348914Z",
     "iopub.status.busy": "2023-11-01T09:59:35.348219Z",
     "iopub.status.idle": "2023-11-01T09:59:35.357977Z",
     "shell.execute_reply": "2023-11-01T09:59:35.357119Z",
     "shell.execute_reply.started": "2023-11-01T09:59:35.348850Z"
    },
    "id": "XSz-Kzkn5JBi",
    "outputId": "d9bc7409-e31c-4eaa-e08b-c6b598df5337"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "97 48\n"
     ]
    }
   ],
   "source": [
    "# split into train and test sets\n",
    "train_size = int(len(dataset) * 0.67)\n",
    "test_size = len(dataset) - train_size\n",
    "train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:]\n",
    "print(len(train), len(test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7xORoyyN5VDH"
   },
   "source": [
    "> You can write a simple function to convert the single column of data into a two-column dataset: the first column containing this month’s (t) passenger count and the second column containing next month’s (t+1) passenger count to be predicted.\n",
    "\n",
    ">Now, you can define a function to create a new dataset, as described above. The function takes two arguments: the dataset, which is a NumPy array you want to convert into a dataset, and the look_back, which is the number of previous time steps to use as input variables to predict the next time period—in this case, defaulted to 1.\n",
    "\n",
    ">This default will create a dataset where X is the number of passengers at a given time (t), and Y is the number of passengers at the next time (t + 1).\n",
    "\n",
    "It can be configured by constructing a differently shaped dataset in the next section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:35.359616Z",
     "iopub.status.busy": "2023-11-01T09:59:35.359098Z",
     "iopub.status.idle": "2023-11-01T09:59:35.371088Z",
     "shell.execute_reply": "2023-11-01T09:59:35.369876Z",
     "shell.execute_reply.started": "2023-11-01T09:59:35.359587Z"
    },
    "id": "tRU_Z7wn5SdY"
   },
   "outputs": [],
   "source": [
    "# convert an array of values into a dataset matrix\n",
    "def create_dataset(dataset, look_back=1):\n",
    "\tdataX, dataY = [], []\n",
    "\tfor i in range(len(dataset)-look_back-1):\n",
    "\t\ta = dataset[i:(i+look_back), 0]\n",
    "\t\tdataX.append(a)\n",
    "\t\tdataY.append(dataset[i + look_back, 0])\n",
    "\treturn np.array(dataX), np.array(dataY)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Whxs1blW5zoe"
   },
   "source": [
    "Let’s take a look at the effect of this function on the first rows of the dataset (shown in the unnormalized form for clarity).\n",
    "\n",
    "```\n",
    "X\t\tY\n",
    "112\t\t118\n",
    "118\t\t132\n",
    "132\t\t129\n",
    "129\t\t121\n",
    "121\t\t135\n",
    "```\n",
    "\n",
    "If you compare these first five rows to the original dataset sample listed in the previous section, you can see the X=t and Y=t+1 pattern in the numbers.\n",
    "\n",
    "Let’s use this function to prepare the train and test datasets for modeling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:35.373320Z",
     "iopub.status.busy": "2023-11-01T09:59:35.372869Z",
     "iopub.status.idle": "2023-11-01T09:59:35.381175Z",
     "shell.execute_reply": "2023-11-01T09:59:35.380173Z",
     "shell.execute_reply.started": "2023-11-01T09:59:35.373280Z"
    },
    "id": "XFnHCApl6CMc"
   },
   "outputs": [],
   "source": [
    "# reshape into X=t and Y=t+1\n",
    "look_back = 1\n",
    "trainX, trainY = create_dataset(train, look_back)\n",
    "testX, testY = create_dataset(test, look_back)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fFo5NhgW6JNc"
   },
   "source": [
    "The LSTM network expects the input data (X) to be provided with a specific array structure in the form of [samples, time steps, features].\n",
    "\n",
    "Currently, the data is in the form of [samples, features], and you are framing the problem as one time step for each sample. You can transform the prepared train and test input data into the expected structure using numpy.reshape() as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:35.383166Z",
     "iopub.status.busy": "2023-11-01T09:59:35.382730Z",
     "iopub.status.idle": "2023-11-01T09:59:35.395073Z",
     "shell.execute_reply": "2023-11-01T09:59:35.393983Z",
     "shell.execute_reply.started": "2023-11-01T09:59:35.383127Z"
    },
    "id": "XAkPk_Hp6K3k",
    "outputId": "764c5681-a6f7-432f-a5c6-0a0f4f557d18"
   },
   "outputs": [],
   "source": [
    "# reshape input to be [samples, time steps, features]\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",
    "print(trainX.shape)\n",
    "print(testX.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LHC1cFCL6_mK"
   },
   "source": [
    "# Design and Evaluation of the LSTM network \n",
    ">You are now ready to design and fit your LSTM network for this problem.\n",
    "\n",
    ">The network has a visible layer with 1 input, a hidden layer with 4 LSTM blocks or neurons, and an output layer that makes a single value prediction. The default sigmoid activation function is used for the LSTM blocks. The network is trained for 100 epochs, and a batch size of 1 is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:35.398378Z",
     "iopub.status.busy": "2023-11-01T09:59:35.397921Z",
     "iopub.status.idle": "2023-11-01T09:59:54.925208Z",
     "shell.execute_reply": "2023-11-01T09:59:54.924415Z",
     "shell.execute_reply.started": "2023-11-01T09:59:35.398338Z"
    },
    "id": "3PohE8fG7Nz8",
    "outputId": "5bdae2c9-d435-470b-b40d-c62a9d6f1aab"
   },
   "outputs": [],
   "source": [
    "# create and fit the LSTM network\n",
    "model = Sequential()\n",
    "model.add(LSTM(4, input_shape=(1, look_back)))\n",
    "model.add(Dense(1))\n",
    "model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rwGjfy6z7hzB"
   },
   "source": [
    "Once the model is fit, you can estimate the performance of the model on the train and test datasets. This will give you a point of comparison for new models.\n",
    "\n",
    "Note that you will invert the predictions before calculating error scores to ensure that performance is reported in the same units as the original data (thousands of passengers per month)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:54.926837Z",
     "iopub.status.busy": "2023-11-01T09:59:54.926291Z",
     "iopub.status.idle": "2023-11-01T09:59:55.481285Z",
     "shell.execute_reply": "2023-11-01T09:59:55.479948Z",
     "shell.execute_reply.started": "2023-11-01T09:59:54.926807Z"
    },
    "id": "w52cK3C47ixs",
    "outputId": "1e3cd4ef-bd1a-4b71-d0a7-0b3abe3d8765"
   },
   "outputs": [],
   "source": [
    "# make predictions\n",
    "trainPredict = model.predict(trainX)\n",
    "testPredict = model.predict(testX)\n",
    "# invert predictions\n",
    "trainPredict = scaler.inverse_transform(trainPredict)\n",
    "trainY = scaler.inverse_transform([trainY])\n",
    "testPredict = scaler.inverse_transform(testPredict)\n",
    "testY = scaler.inverse_transform([testY])\n",
    "# calculate root mean squared error\n",
    "trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n",
    "print('Train Score: %.2f RMSE' % (trainScore))\n",
    "testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n",
    "print('Test Score: %.2f RMSE' % (testScore))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DX2ba__n7p8w"
   },
   "source": [
    ">You can see that the model has an average error of about 23 passengers (in thousands) on the training dataset and about 49 passengers (in thousands) on the test dataset. Not that bad.\n",
    "\n",
    ">Finally, you can generate predictions using the model for both the train and test dataset to get a visual indication of the skill of the model.\n",
    "\n",
    ">Because of how the dataset was prepared, you must shift the predictions so that they align on the x-axis with the original dataset. Once prepared, the data is plotted, showing the original dataset in blue, the predictions for the training dataset in green, and the predictions on the unseen test dataset in red"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 265
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:55.485696Z",
     "iopub.status.busy": "2023-11-01T09:59:55.485338Z",
     "iopub.status.idle": "2023-11-01T09:59:55.682888Z",
     "shell.execute_reply": "2023-11-01T09:59:55.681610Z",
     "shell.execute_reply.started": "2023-11-01T09:59:55.485667Z"
    },
    "id": "ejZA9Oyu7spv",
    "outputId": "8b3d4335-4c8a-4992-9c65-6522f73f304f"
   },
   "outputs": [],
   "source": [
    "# shift train predictions for plotting\n",
    "trainPredictPlot = np.empty_like(dataset)\n",
    "trainPredictPlot[:, :] = np.nan\n",
    "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n",
    "# shift test predictions for plotting\n",
    "testPredictPlot = np.empty_like(dataset)\n",
    "testPredictPlot[:, :] = np.nan\n",
    "testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n",
    "# plot baseline and predictions\n",
    "plt.plot(scaler.inverse_transform(dataset))\n",
    "plt.plot(trainPredictPlot)\n",
    "plt.plot(testPredictPlot)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "E4TYIc5-72ZY"
   },
   "source": [
    ">You can see that the model did an excellent job of fitting both the training and the test datasets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AwYc1EDW8U9s"
   },
   "source": [
    "# LSTM for Regression Using the Window Method\n",
    "You can also phrase the problem so that multiple, recent time steps can be used to make the prediction for the next time step.\n",
    "\n",
    "This is called a window, and the size of the window is a parameter that can be tuned for each problem.\n",
    "\n",
    "For example, given the current time (t) to predict the value at the next time in the sequence (t+1), you can use the current time (t), as well as the two prior times (t-1 and t-2) as input variables.\n",
    "\n",
    "When phrased as a regression problem, the input variables are t-2, t-1, and t, and the output variable is t+1.\n",
    "\n",
    "The create_dataset() function created in the previous section allows you to create this formulation of the time series problem by increasing the look_back argument from 1 to 3.\n",
    "\n",
    "A sample of the dataset with this formulation is as follows:\n",
    "\n",
    "\n",
    "```\n",
    "X1\tX2\tX3\tY\n",
    "112\t118\t132\t129\n",
    "118\t132\t129\t121\n",
    "132\t129\t121\t135\n",
    "129\t121\t135\t148\n",
    "121\t135\t148\t148\n",
    "```\n",
    "You can re-run the example in the previous section with the larger window size. The whole code listing with just the window size change is listed below for completeness.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T09:59:55.684760Z",
     "iopub.status.busy": "2023-11-01T09:59:55.684433Z",
     "iopub.status.idle": "2023-11-01T10:00:26.562463Z",
     "shell.execute_reply": "2023-11-01T10:00:26.561251Z",
     "shell.execute_reply.started": "2023-11-01T09:59:55.684732Z"
    },
    "id": "aTkqHEf77xRM",
    "outputId": "ce69159c-7a40-4e33-a502-fd6f1b9f4144",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/dist-packages/keras/src/layers/rnn/rnn.py:204: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.\n",
      "  super().__init__(**kwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "84/84 - 2s - 22ms/step - loss: 0.0425\n",
      "Epoch 2/10\n",
      "84/84 - 0s - 2ms/step - loss: 0.0124\n",
      "Epoch 3/10\n",
      "84/84 - 0s - 1ms/step - loss: 0.0088\n",
      "Epoch 4/10\n",
      "84/84 - 0s - 1ms/step - loss: 0.0074\n",
      "Epoch 5/10\n",
      "84/84 - 0s - 1ms/step - loss: 0.0065\n",
      "Epoch 6/10\n",
      "84/84 - 0s - 1ms/step - loss: 0.0053\n",
      "Epoch 7/10\n",
      "84/84 - 0s - 1ms/step - loss: 0.0045\n",
      "Epoch 8/10\n",
      "84/84 - 0s - 1ms/step - loss: 0.0039\n",
      "Epoch 9/10\n",
      "84/84 - 0s - 1ms/step - loss: 0.0036\n",
      "Epoch 10/10\n",
      "84/84 - 0s - 1ms/step - loss: 0.0034\n",
      "\u001b[1m3/3\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 80ms/step\n",
      "\u001b[1m2/2\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 3ms/step \n",
      "Train Score: 28.98 RMSE\n",
      "Test Score: 82.74 RMSE\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# reshape into X=t and Y=t+1\n",
    "look_back = 12\n",
    "trainX, trainY = create_dataset(train, look_back)\n",
    "testX, testY = create_dataset(test, look_back)\n",
    "# reshape input to be [samples, time steps, features]\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",
    "# create and fit the LSTM network\n",
    "model = Sequential()\n",
    "model.add(LSTM(4, input_shape=(1, look_back),return_sequences=True))\n",
    "\n",
    "# fix --------- the dense layer should be of last\n",
    "# model.add(Dense(1))\n",
    "model.add(LSTM(4))\n",
    "model.add(Dense(1)) \n",
    "\n",
    "model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "model.fit(trainX, trainY, epochs=10, batch_size=1, verbose=2) # change epochs=10 instead of 100 for fast reproducing\n",
    "\n",
    "# make predictions\n",
    "trainPredict = model.predict(trainX)\n",
    "testPredict = model.predict(testX)\n",
    "# invert predictions\n",
    "trainPredict = scaler.inverse_transform(trainPredict)\n",
    "trainY = scaler.inverse_transform([trainY])\n",
    "testPredict = scaler.inverse_transform(testPredict)\n",
    "testY = scaler.inverse_transform([testY])\n",
    "# calculate root mean squared error\n",
    "trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n",
    "print('Train Score: %.2f RMSE' % (trainScore))\n",
    "testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n",
    "print('Test Score: %.2f RMSE' % (testScore))\n",
    "# shift train predictions for plotting\n",
    "trainPredictPlot = np.empty_like(dataset)\n",
    "trainPredictPlot[:, :] = np.nan\n",
    "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n",
    "# shift test predictions for plotting\n",
    "testPredictPlot = np.empty_like(dataset)\n",
    "testPredictPlot[:, :] = np.nan\n",
    "testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n",
    "# plot baseline and predictions\n",
    "plt.plot(scaler.inverse_transform(dataset))\n",
    "plt.plot(trainPredictPlot)\n",
    "plt.plot(testPredictPlot)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3NyP3P6Z9Wko"
   },
   "source": [
    "# LSTM for Regression with Time Steps\n",
    ">You may have noticed that the data preparation for the LSTM network includes time steps.\n",
    "\n",
    ">Some sequence problems may have a varied number of time steps per sample. For example, you may have measurements of a physical machine leading up to the point of failure or a point of surge. Each incident would be a sample of observations that lead up to the event, which would be the time steps, and the variables observed would be the features.\n",
    "\n",
    ">Time steps provide another way to phrase your time series problem. Like above in the window example, you can take prior time steps in your time series as inputs to predict the output at the next time step.\n",
    "\n",
    ">Instead of phrasing the past observations as separate input features, you can use them as time steps of the one input feature, which is indeed a more accurate framing of the problem.\n",
    "\n",
    ">You can do this using the same data representation as in the previous window-based example, except when you reshape the data, you set the columns to be the time steps dimension and change the features dimension back to 1. For example:\n",
    "\n",
    "\n",
    "\n",
    "```\n",
    "# reshape input to be [samples, time steps, features]\n",
    "trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))\n",
    "testX = np.reshape(testX, (testX.shape[0], testX.shape[1], 1))\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T10:01:53.148736Z",
     "iopub.status.busy": "2023-11-01T10:01:53.148279Z",
     "iopub.status.idle": "2023-11-01T10:01:53.158509Z",
     "shell.execute_reply": "2023-11-01T10:01:53.157306Z",
     "shell.execute_reply.started": "2023-11-01T10:01:53.148703Z"
    },
    "id": "rwz_a87O9hWt",
    "outputId": "90dba386-27de-430f-883a-06c47663fdbc"
   },
   "outputs": [],
   "source": [
    "# reshape into X=t and Y=t+1\n",
    "look_back = 3\n",
    "trainX, trainY = create_dataset(train, look_back)\n",
    "testX, testY = create_dataset(test, look_back)\n",
    "# reshape input to be [samples, time steps, features]\n",
    "trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))\n",
    "testX = np.reshape(testX, (testX.shape[0], testX.shape[1], 1))\n",
    "\n",
    "print(trainX.shape)\n",
    "print(trainY.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T10:01:53.161745Z",
     "iopub.status.busy": "2023-11-01T10:01:53.160801Z",
     "iopub.status.idle": "2023-11-01T10:02:19.274959Z",
     "shell.execute_reply": "2023-11-01T10:02:19.273867Z",
     "shell.execute_reply.started": "2023-11-01T10:01:53.161705Z"
    },
    "id": "JEMfK1yUAYHA",
    "outputId": "cacea859-99b0-4db9-f82f-37cb89db7ab8"
   },
   "outputs": [],
   "source": [
    "# create and fit the LSTM network\n",
    "model = Sequential()\n",
    "model.add(LSTM(4, input_shape=(look_back, 1)))\n",
    "model.add(Dense(1))\n",
    "model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "model.fit(trainX, trainY, epochs=100, batch_size=1, verbose=2)\n",
    "# make predictions\n",
    "trainPredict = model.predict(trainX)\n",
    "testPredict = model.predict(testX)\n",
    "# invert predictions\n",
    "trainPredict = scaler.inverse_transform(trainPredict)\n",
    "trainY = scaler.inverse_transform([trainY])\n",
    "testPredict = scaler.inverse_transform(testPredict)\n",
    "testY = scaler.inverse_transform([testY])\n",
    "# calculate root mean squared error\n",
    "trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n",
    "print('Train Score: %.2f RMSE' % (trainScore))\n",
    "testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n",
    "print('Test Score: %.2f RMSE' % (testScore))\n",
    "# shift train predictions for plotting\n",
    "trainPredictPlot = np.empty_like(dataset)\n",
    "trainPredictPlot[:, :] = np.nan\n",
    "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n",
    "# shift test predictions for plotting\n",
    "testPredictPlot = np.empty_like(dataset)\n",
    "testPredictPlot[:, :] = np.nan\n",
    "testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n",
    "# plot baseline and predictions\n",
    "plt.plot(scaler.inverse_transform(dataset))\n",
    "plt.plot(trainPredictPlot)\n",
    "plt.plot(testPredictPlot)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bMgOCG4tIH8M"
   },
   "source": [
    "# LSTM with Memory Between Batches\n",
    ">The LSTM network has memory capable of remembering across long sequences.\n",
    "\n",
    ">Normally, the state within the network is reset after each training batch when fitting the model, as well as each call to model.predict() or model.evaluate().\n",
    "\n",
    ">You can gain finer control over when the internal state of the LSTM network is cleared in Keras by making the LSTM layer “stateful.” This means it can build a state over the entire training sequence and even maintain that state if needed to make predictions.\n",
    "\n",
    ">It requires that the training data not be shuffled when fitting the network. It also requires explicit resetting of the network state after each exposure to the training data (epoch) by calls to model.reset_states(). This means that you must create your own outer loop of epochs and within each epoch call model.fit() and model.reset_states(). For example:\n",
    "\n",
    "```\n",
    "for i in range(100):\n",
    "\tmodel.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)\n",
    "\tmodel.reset_states()\n",
    "```\n",
    "\n",
    "Finally, when the LSTM layer is constructed, the stateful parameter must be set to True. Instead of specifying the input dimensions, you must hard code the number of samples in a batch, the number of time steps in a sample, and the number of features in a time step by setting the batch_input_shape parameter. For example:\n",
    "\n",
    "\n",
    "`model.add(LSTM(4, batch_input_shape=(batch_size, time_steps, features), stateful=True))`\n",
    "\n",
    "This same batch size must then be used later when evaluating the model and making predictions. For example:\n",
    "\n",
    "`model.predict(trainX, batch_size=batch_size)`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T10:02:19.277599Z",
     "iopub.status.busy": "2023-11-01T10:02:19.276459Z",
     "iopub.status.idle": "2023-11-01T10:03:13.502072Z",
     "shell.execute_reply": "2023-11-01T10:03:13.500661Z",
     "shell.execute_reply.started": "2023-11-01T10:02:19.277540Z"
    },
    "id": "EgFD6YvZJuvQ",
    "outputId": "b8e9c0db-6e78-4aca-e07c-30d400d57498"
   },
   "outputs": [],
   "source": [
    "# reshape into X=t and Y=t+1\n",
    "look_back = 12\n",
    "trainX, trainY = create_dataset(train, look_back)\n",
    "testX, testY = create_dataset(test, look_back)\n",
    "# reshape input to be [samples, time steps, features]\n",
    "trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))\n",
    "testX = np.reshape(testX, (testX.shape[0], testX.shape[1], 1))\n",
    "# create and fit the LSTM network\n",
    "batch_size = 1\n",
    "model = Sequential()\n",
    "model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))\n",
    "model.add(Dense(1))\n",
    "model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "for i in range(100):\n",
    "\tmodel.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)\n",
    "\tmodel.reset_states()\n",
    "# make predictions\n",
    "trainPredict = model.predict(trainX, batch_size=batch_size)\n",
    "model.reset_states()\n",
    "testPredict = model.predict(testX, batch_size=batch_size)\n",
    "model.reset_states()\n",
    "# invert predictions\n",
    "trainPredict = scaler.inverse_transform(trainPredict)\n",
    "trainY = scaler.inverse_transform([trainY])\n",
    "testPredict = scaler.inverse_transform(testPredict)\n",
    "testY = scaler.inverse_transform([testY])\n",
    "# calculate root mean squared error\n",
    "trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n",
    "print('Train Score: %.2f RMSE' % (trainScore))\n",
    "testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n",
    "print('Test Score: %.2f RMSE' % (testScore))\n",
    "# shift train predictions for plotting\n",
    "trainPredictPlot = np.empty_like(dataset)\n",
    "trainPredictPlot[:, :] = np.nan\n",
    "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n",
    "# shift test predictions for plotting\n",
    "testPredictPlot = np.empty_like(dataset)\n",
    "testPredictPlot[:, :] = np.nan\n",
    "testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n",
    "# plot baseline and predictions\n",
    "plt.plot(scaler.inverse_transform(dataset))\n",
    "plt.plot(trainPredictPlot)\n",
    "plt.plot(testPredictPlot)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tdXIYsqbLhZ1"
   },
   "source": [
    "You do see that results are better than some, worse than others. The model may need more modules and may need to be trained for more epochs to internalize the structure of the problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eexs34jUNPvk"
   },
   "source": [
    "# Stacked LSTMs with Memory Between Batches\n",
    "Finally, let’s take a look at one of the big benefits of LSTMs: the fact that they can be successfully trained when stacked into deep network architectures.\n",
    "\n",
    "LSTM networks can be stacked in Keras in the same way that other layer types can be stacked. One addition to the configuration that is required is that an LSTM layer prior to each subsequent LSTM layer must return the sequence. This can be done by setting the return_sequences parameter on the layer to True.\n",
    "\n",
    "You can extend the stateful LSTM in the previous section to have two layers, as follows:\n",
    "\n",
    "```\n",
    "model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True, return_sequences=True))\n",
    "model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))\n",
    "\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "execution": {
     "iopub.execute_input": "2023-11-01T10:03:13.504085Z",
     "iopub.status.busy": "2023-11-01T10:03:13.503510Z",
     "iopub.status.idle": "2023-11-01T10:06:41.861866Z",
     "shell.execute_reply": "2023-11-01T10:06:41.860688Z",
     "shell.execute_reply.started": "2023-11-01T10:03:13.504012Z"
    },
    "id": "mRnZZrDzNZNf",
    "outputId": "dc1d3e75-c6a6-41df-fa3b-d04d54126b96",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# reshape into X=t and Y=t+1\n",
    "look_back = 12\n",
    "trainX, trainY = create_dataset(train, look_back)\n",
    "testX, testY = create_dataset(test, look_back)\n",
    "# reshape input to be [samples, time steps, features]\n",
    "trainX = np.reshape(trainX, (trainX.shape[0], trainX.shape[1], 1))\n",
    "testX = np.reshape(testX, (testX.shape[0], testX.shape[1], 1))\n",
    "# create and fit the LSTM network\n",
    "batch_size = 1\n",
    "model = Sequential()\n",
    "model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True, return_sequences=True))\n",
    "model.add(LSTM(4, batch_input_shape=(batch_size, look_back, 1), stateful=True))\n",
    "model.add(Dense(1))\n",
    "model.compile(loss='mean_squared_error', optimizer='adam')\n",
    "for i in range(300):\n",
    "\tmodel.fit(trainX, trainY, epochs=1, batch_size=batch_size, verbose=2, shuffle=False)\n",
    "\tmodel.reset_states()\n",
    "# make predictions\n",
    "trainPredict = model.predict(trainX, batch_size=batch_size)\n",
    "model.reset_states()\n",
    "testPredict = model.predict(testX, batch_size=batch_size)\n",
    "model.reset_states()\n",
    "# invert predictions\n",
    "trainPredict = scaler.inverse_transform(trainPredict)\n",
    "trainY = scaler.inverse_transform([trainY])\n",
    "testPredict = scaler.inverse_transform(testPredict)\n",
    "testY = scaler.inverse_transform([testY])\n",
    "# calculate root mean squared error\n",
    "trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n",
    "print('Train Score: %.2f RMSE' % (trainScore))\n",
    "testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n",
    "print('Test Score: %.2f RMSE' % (testScore))\n",
    "# shift train predictions for plotting\n",
    "trainPredictPlot = np.empty_like(dataset)\n",
    "trainPredictPlot[:, :] = np.nan\n",
    "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n",
    "# shift test predictions for plotting\n",
    "testPredictPlot = np.empty_like(dataset)\n",
    "testPredictPlot[:, :] = np.nan\n",
    "testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n",
    "# plot baseline and predictions\n",
    "plt.plot(scaler.inverse_transform(dataset))\n",
    "plt.plot(trainPredictPlot)\n",
    "plt.plot(testPredictPlot)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wLhvc98wO0sT"
   },
   "source": [
    "# Summary\n",
    "In this tutorial, you discovered how to develop LSTM \n",
    "\n",
    "recurrent neural networks for time series prediction in Python with the Keras deep learning network.\n",
    "\n",
    "Specifically, you learned:\n",
    "\n",
    "*   About the international airline passenger time series prediction problem\n",
    "*   How to create an LSTM for a regression and a window formulation of the time series problem\n",
    "*   How to create an LSTM with a time step formulation of the time series problem\n",
    "*   How to create an LSTM with state and stacked LSTMs with state to learn long sequences"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}