time_series_notes_pred.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **Time Series Prediction Notes-Vedant Naik**"
      ],
      "metadata": {
        "id": "f_Zi3w_dUd5o"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Long Short-Term Memory (LSTM)\n",
        "This type of networks are a type of recurrent neural network (RNN) designed to address the challenges of learning long-term dependencies in sequences of data. Unlike traditional RNNs, which struggle with vanishing and exploding gradients, LSTMs can retain information over long periods, making them suitable for tasks involving sequential data such as time series analysis, natural language processing, and speech recognition.\n",
        "\n",
        ">Imagine you're reading a book, and you come across a character named \"Sam\" in chapter 15, whom you last saw in chapter 1. To understand the plot, your brain naturally connects the information about Sam from chapter 1 to her actions in chapter 15. This ability to remember and utilize past information over long intervals is precisely what LSTMs are designed to mimic in neural networks.\n",
        "\n",
        ">LSTMs achieve this through a special architecture that includes memory cells and three types of gates:\n",
        "\n",
        ">>Forget Gate: Determines which information to discard from the cell state.\n",
        "\n",
        ">>Input Gate: Updates the cell state with new information.\n",
        "\n",
        ">>Output Gate: Decides what the next hidden state should be, based on the current input and the memory of the cell.\n",
        "\n",
        "Each of these gates can learn which data in a sequence is important to keep or throw away, making it possible for LSTMs to learn and remember over long sequences of inputs."
      ],
      "metadata": {
        "id": "-A--OB8nV5pN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's now create reusable tools/functions for the usage of LSTM networks.\n",
        "> # **Single Feature input and Output - forecasting LSTM**"
      ],
      "metadata": {
        "id": "ukbCsn78WjQ7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#This section includes basic/required imports\n",
        "import tensorflow as tf\n",
        "import os # optional if not reading a zip file..etc\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras.callbacks import ModelCheckpoint\n",
        "from tensorflow.keras.losses import MeanSquaredError\n",
        "from tensorflow.keras.metrics import RootMeanSquaredError\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from tensorflow.keras.models import load_model\n",
        "# lets assume we are reading a free online data set\n",
        "# Replace the Data set according to requirements\n",
        "# Begin Data\n",
        "zip_path = tf.keras.utils.get_file(\n",
        "    origin='https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip',\n",
        "    fname='jena_climate_2009_2016.csv.zip',\n",
        "    extract=True)\n",
        "csv_path, _ = os.path.splitext(zip_path)\n",
        "df = pd.read_csv(csv_path)\n",
        "df.head(3)\n",
        "#End Data\n",
        "\n",
        "#Convert the date time stamp of data to Pandas date time form  ## Not used rn, would be useful in future\n",
        "df.index = pd.to_datetime(df['Date Time'], format='%d.%m.%Y %H:%M:%S')\n",
        "\n",
        "# Selecting the only feature to forecast\n",
        "temp = df['T (degC)']\n",
        "\n",
        "# Defining window for predictions, optional but generally helpful... this means taking values x and forecasting x+1\n",
        "def df_to_X_y(df, window_size=5):\n",
        "  df_as_np = df.to_numpy()\n",
        "  X = []\n",
        "  y = []\n",
        "  for i in range(len(df_as_np)-window_size):\n",
        "    row = [[a] for a in df_as_np[i:i+window_size]]\n",
        "    X.append(row)\n",
        "    label = df_as_np[i+window_size]\n",
        "    y.append(label)\n",
        "  return np.array(X), np.array(y)\n",
        "# This function would essentially do something like this:\n",
        "#         INPUT                                       | OUTPUT\n",
        "# [[[temp 1], [temp 2], [temp 3], [temp 4], [temp 5]]] [temp 6]\n",
        "# [[[temp 2], [temp 3], [temp 4], [temp 5], [temp 6]]] [temp 7]\n",
        "# [[[temp 3], [temp 4], [temp 5], [temp 6], [temp 7]]] [temp 8]\n",
        "\n",
        "WINDOW_SIZE = 5\n",
        "X1, y1 = df_to_X_y(temp, WINDOW_SIZE)\n",
        "X1.shape, y1.shape\n",
        "\n",
        "X_train1, y_train1 = X1[:60000], y1[:60000]\n",
        "X_val1, y_val1 = X1[60000:65000], y1[60000:65000]\n",
        "X_test1, y_test1 = X1[65000:], y1[65000:]\n",
        "X_train1.shape, y_train1.shape, X_val1.shape, y_val1.shape, X_test1.shape, y_test1.shape\n",
        "\n",
        "# Defining Model Architecture\n",
        "model1 = Sequential()\n",
        "model1.add(InputLayer((5, 1)))\n",
        "model1.add(LSTM(64))\n",
        "model1.add(Dense(8, 'relu'))\n",
        "model1.add(Dense(1, 'linear'))\n",
        "\n",
        "model1.summary()\n",
        "# Defining callbacks to save most apt model\n",
        "cp1 = ModelCheckpoint('model1/', save_best_only=True)\n",
        "model1.compile(loss=MeanSquaredError(), optimizer=Adam(learning_rate=0.0001), metrics=[RootMeanSquaredError()])\n",
        "\n",
        "#Train the model\n",
        "model1.fit(X_train1, y_train1, validation_data=(X_val1, y_val1), epochs=10, callbacks=[cp1])\n",
        "\n",
        "#Load best trained model saved by call back\n",
        "model1 = load_model('model1/')\n",
        "\n",
        "# Test model on training data set\n",
        "train_predictions = model1.predict(X_train1).flatten()\n",
        "train_results = pd.DataFrame(data={'Train Predictions':train_predictions, 'Actuals':y_train1})\n",
        "plt.plot(train_results['Train Predictions'][50:100])\n",
        "plt.plot(train_results['Actuals'][50:100])\n",
        "\n",
        "# Test Model on Validation data set\n",
        "val_predictions = model1.predict(X_val1).flatten()\n",
        "val_results = pd.DataFrame(data={'Val Predictions':val_predictions, 'Actuals':y_val1})\n",
        "plt.plot(val_results['Val Predictions'][:100])\n",
        "plt.plot(val_results['Actuals'][:100])\n",
        "\n",
        "# Test Model on test data set\n",
        "test_predictions = model1.predict(X_test1).flatten()\n",
        "test_results = pd.DataFrame(data={'Test Predictions':test_predictions, 'Actuals':y_test1})\n",
        "plt.plot(test_results['Test Predictions'][:100])\n",
        "plt.plot(test_results['Actuals'][:100])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "lN_GaXL-Wxtu",
        "outputId": "462ac3d1-59c3-40ff-ee13-b206ee937f60"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " lstm_1 (LSTM)               (None, 64)                16896     \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 8)                 520       \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 1)                 9         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 17425 (68.07 KB)\n",
            "Trainable params: 17425 (68.07 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n",
            "Epoch 1/10\n",
            "1875/1875 [==============================] - 20s 8ms/step - loss: 95.4997 - root_mean_squared_error: 9.7724 - val_loss: 1.8395 - val_root_mean_squared_error: 1.3563\n",
            "Epoch 2/10\n",
            "1875/1875 [==============================] - 16s 9ms/step - loss: 5.3043 - root_mean_squared_error: 2.3031 - val_loss: 0.1696 - val_root_mean_squared_error: 0.4118\n",
            "Epoch 3/10\n",
            "1875/1875 [==============================] - 20s 11ms/step - loss: 0.7893 - root_mean_squared_error: 0.8884 - val_loss: 0.1097 - val_root_mean_squared_error: 0.3312\n",
            "Epoch 4/10\n",
            "1875/1875 [==============================] - 14s 7ms/step - loss: 0.2162 - root_mean_squared_error: 0.4650 - val_loss: 0.0735 - val_root_mean_squared_error: 0.2712\n",
            "Epoch 5/10\n",
            "1875/1875 [==============================] - 15s 8ms/step - loss: 0.0996 - root_mean_squared_error: 0.3156 - val_loss: 0.0609 - val_root_mean_squared_error: 0.2467\n",
            "Epoch 6/10\n",
            "1875/1875 [==============================] - 14s 7ms/step - loss: 0.0691 - root_mean_squared_error: 0.2628 - val_loss: 0.0608 - val_root_mean_squared_error: 0.2465\n",
            "Epoch 7/10\n",
            "1875/1875 [==============================] - 17s 9ms/step - loss: 0.0569 - root_mean_squared_error: 0.2386 - val_loss: 0.0516 - val_root_mean_squared_error: 0.2272\n",
            "Epoch 8/10\n",
            "1875/1875 [==============================] - 18s 9ms/step - loss: 0.0515 - root_mean_squared_error: 0.2268 - val_loss: 0.0486 - val_root_mean_squared_error: 0.2205\n",
            "Epoch 9/10\n",
            "1875/1875 [==============================] - 15s 8ms/step - loss: 0.0483 - root_mean_squared_error: 0.2198 - val_loss: 0.0471 - val_root_mean_squared_error: 0.2171\n",
            "Epoch 10/10\n",
            "1875/1875 [==============================] - 17s 9ms/step - loss: 0.0464 - root_mean_squared_error: 0.2154 - val_loss: 0.0459 - val_root_mean_squared_error: 0.2142\n",
            "1875/1875 [==============================] - 5s 2ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x794fee9be470>]"
            ]
          },
          "metadata": {},
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> # **Multiple Input and Single Output Forecasting LSTM**\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "e9R2a9D6bGU7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#This section includes basic/required imports\n",
        "import tensorflow as tf\n",
        "import os # optional if not reading a zip file..etc\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras.callbacks import ModelCheckpoint\n",
        "from tensorflow.keras.losses import MeanSquaredError\n",
        "from tensorflow.keras.metrics import RootMeanSquaredError\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from sklearn.metrics import mean_squared_error as mse\n",
        "from tensorflow.keras.models import load_model\n",
        "# lets assume we are reading a free online data set\n",
        "# Replace the Data set according to requirements\n",
        "# Begin Data\n",
        "zip_path = tf.keras.utils.get_file(\n",
        "    origin='https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip',\n",
        "    fname='jena_climate_2009_2016.csv.zip',\n",
        "    extract=True)\n",
        "csv_path, _ = os.path.splitext(zip_path)\n",
        "df = pd.read_csv(csv_path)\n",
        "df.head(3)\n",
        "#End Data\n",
        "\n",
        "#Convert the date time stamp of data to Pandas date time form\n",
        "df.index = pd.to_datetime(df['Date Time'], format='%d.%m.%Y %H:%M:%S')\n",
        "\n",
        "# Selecting Data\n",
        "temp_df = pd.DataFrame({'Temperature':temp})\n",
        "temp_df['Seconds'] = temp_df.index.map(pd.Timestamp.timestamp)\n",
        "\n",
        "#Lets create a function to plot pred vs truth\n",
        "def plot_predictions1(model, X, y, start=0, end=100):\n",
        "  predictions = model.predict(X).flatten()\n",
        "  df = pd.DataFrame(data={'Predictions':predictions, 'Actuals':y})\n",
        "  plt.plot(df['Predictions'][start:end])\n",
        "  plt.plot(df['Actuals'][start:end])\n",
        "  return df, mse(y, predictions)\n",
        "\n",
        "# Definign the cyclical nature of time with Day/Year sin and cos.\n",
        "day = 60*60*24\n",
        "year = 365.2425*day\n",
        "\n",
        "temp_df['Day sin'] = np.sin(temp_df['Seconds'] * (2* np.pi / day))\n",
        "temp_df['Day cos'] = np.cos(temp_df['Seconds'] * (2 * np.pi / day))\n",
        "temp_df['Year sin'] = np.sin(temp_df['Seconds'] * (2 * np.pi / year))\n",
        "temp_df['Year cos'] = np.cos(temp_df['Seconds'] * (2 * np.pi / year))\n",
        "temp_df.head()\n",
        "\n",
        "# Get rid of seconds... monotonous increasing\n",
        "temp_df = temp_df.drop('Seconds', axis=1)\n",
        "temp_df.head()\n",
        "\n",
        "# Processing the data for network\n",
        "def df_to_X_y2(df, window_size=6):\n",
        "  df_as_np = df.to_numpy()\n",
        "  X = []\n",
        "  y = []\n",
        "  for i in range(len(df_as_np)-window_size):\n",
        "    row = [r for r in df_as_np[i:i+window_size]]\n",
        "    X.append(row)\n",
        "    label = df_as_np[i+window_size][0]\n",
        "    y.append(label)\n",
        "  return np.array(X), np.array(y)\n",
        "\n",
        "X2, y2 = df_to_X_y2(temp_df)\n",
        "\n",
        "X2_train, y2_train = X2[:60000], y2[:60000]\n",
        "X2_val, y2_val = X2[60000:65000], y2[60000:65000]\n",
        "X2_test, y2_test = X2[65000:], y2[65000:]\n",
        "X2_train.shape, y2_train.shape, X2_val.shape, y2_val.shape, X2_test.shape, y2_test.shape\n",
        "\n",
        "# Standardize the data, as the span of all inputs vary signinficatly, thus it may mess with the cost function\n",
        "temp_training_mean = np.mean(X2_train[:, :, 0])\n",
        "temp_training_std = np.std(X2_train[:, :, 0])\n",
        "\n",
        "def preprocess(X):\n",
        "  X[:, :, 0] = (X[:, :, 0] - temp_training_mean) / temp_training_std\n",
        "  return X\n",
        "preprocess(X2_train)\n",
        "preprocess(X2_val)\n",
        "preprocess(X2_test)\n",
        "\n",
        "#Defining Model Architecture\n",
        "model4 = Sequential()\n",
        "model4.add(InputLayer((6, 5)))\n",
        "model4.add(LSTM(64))\n",
        "model4.add(Dense(8, 'relu'))\n",
        "model4.add(Dense(1, 'linear'))\n",
        "\n",
        "model4.summary()\n",
        "\n",
        "#Call backs\n",
        "cp4 = ModelCheckpoint('model4/', save_best_only=True)\n",
        "model4.compile(loss=MeanSquaredError(), optimizer=Adam(learning_rate=0.0001), metrics=[RootMeanSquaredError()])\n",
        "\n",
        "#Train the model\n",
        "model4.fit(X2_train, y2_train, validation_data=(X2_val, y2_val), epochs=10, callbacks=[cp4])\n",
        "plot_predictions1(model4, X2_test, y2_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "KgCqqW42bWl6",
        "outputId": "949a3a76-d1e2-4e65-e731-b3a0c3fe91fe"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_3\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " lstm_3 (LSTM)               (None, 64)                17920     \n",
            "                                                                 \n",
            " dense_6 (Dense)             (None, 8)                 520       \n",
            "                                                                 \n",
            " dense_7 (Dense)             (None, 1)                 9         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 18449 (72.07 KB)\n",
            "Trainable params: 18449 (72.07 KB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n",
            "Epoch 1/10\n",
            "1875/1875 [==============================] - 21s 10ms/step - loss: 26.7714 - root_mean_squared_error: 5.1741 - val_loss: 1.6666 - val_root_mean_squared_error: 1.2910\n",
            "Epoch 2/10\n",
            "1875/1875 [==============================] - 15s 8ms/step - loss: 1.6887 - root_mean_squared_error: 1.2995 - val_loss: 0.5036 - val_root_mean_squared_error: 0.7096\n",
            "Epoch 3/10\n",
            "1875/1875 [==============================] - 14s 8ms/step - loss: 0.4229 - root_mean_squared_error: 0.6503 - val_loss: 0.4065 - val_root_mean_squared_error: 0.6376\n",
            "Epoch 4/10\n",
            "1875/1875 [==============================] - 15s 8ms/step - loss: 0.3017 - root_mean_squared_error: 0.5493 - val_loss: 0.2900 - val_root_mean_squared_error: 0.5385\n",
            "Epoch 5/10\n",
            "1875/1875 [==============================] - 15s 8ms/step - loss: 0.2388 - root_mean_squared_error: 0.4887 - val_loss: 0.2419 - val_root_mean_squared_error: 0.4919\n",
            "Epoch 6/10\n",
            "1875/1875 [==============================] - 14s 7ms/step - loss: 0.1917 - root_mean_squared_error: 0.4379 - val_loss: 0.1839 - val_root_mean_squared_error: 0.4288\n",
            "Epoch 7/10\n",
            "1875/1875 [==============================] - 16s 8ms/step - loss: 0.1565 - root_mean_squared_error: 0.3956 - val_loss: 0.1655 - val_root_mean_squared_error: 0.4069\n",
            "Epoch 8/10\n",
            "1875/1875 [==============================] - 19s 10ms/step - loss: 0.1324 - root_mean_squared_error: 0.3639 - val_loss: 0.1333 - val_root_mean_squared_error: 0.3651\n",
            "Epoch 9/10\n",
            "1875/1875 [==============================] - 13s 7ms/step - loss: 0.1165 - root_mean_squared_error: 0.3414 - val_loss: 0.1355 - val_root_mean_squared_error: 0.3680\n",
            "Epoch 10/10\n",
            "1875/1875 [==============================] - 20s 11ms/step - loss: 0.1074 - root_mean_squared_error: 0.3277 - val_loss: 0.1125 - val_root_mean_squared_error: 0.3354\n",
            "11111/11111 [==============================] - 33s 3ms/step\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(        Predictions  Actuals\n",
              " 0          9.199200     9.11\n",
              " 1          9.151531     8.88\n",
              " 2          9.011153     8.76\n",
              " 3          8.815615     8.92\n",
              " 4          8.782050     9.48\n",
              " ...             ...      ...\n",
              " 355540    -4.043574    -4.05\n",
              " 355541    -3.946816    -3.35\n",
              " 355542    -3.704766    -3.16\n",
              " 355543    -3.492456    -4.23\n",
              " 355544    -3.666331    -4.82\n",
              " \n",
              " [355545 rows x 2 columns],\n",
              " 0.11407808448889221)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "> # **Multiple input and Multiple output network -LSTM**\n",
        "Multiple input -multi related features\n",
        "Multiple output -multiple time step forecast or multifeature output"
      ],
      "metadata": {
        "id": "7DbyXTINdlg8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#This section includes basic/required imports\n",
        "import tensorflow as tf\n",
        "import os # optional if not reading a zip file..etc\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import *\n",
        "from tensorflow.keras.callbacks import ModelCheckpoint\n",
        "from tensorflow.keras.losses import MeanSquaredError\n",
        "from tensorflow.keras.metrics import RootMeanSquaredError\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from tensorflow.keras.models import load_model\n",
        "from sklearn.metrics import mean_squared_error as mse\n",
        "# lets assume we are reading a free online data set\n",
        "# Replace the Data set according to requirements\n",
        "# Begin Data\n",
        "zip_path = tf.keras.utils.get_file(\n",
        "    origin='https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip',\n",
        "    fname='jena_climate_2009_2016.csv.zip',\n",
        "    extract=True)\n",
        "csv_path, _ = os.path.splitext(zip_path)\n",
        "df = pd.read_csv(csv_path)\n",
        "df.head(3)\n",
        "#End Data\n",
        "\n",
        "#Convert the date time stamp of data to Pandas date time form\n",
        "df.index = pd.to_datetime(df['Date Time'], format='%d.%m.%Y %H:%M:%S')\n",
        "\n",
        "# Selecting Data\n",
        "temp_df = pd.DataFrame({'Temperature':temp})\n",
        "temp_df['Seconds'] = temp_df.index.map(pd.Timestamp.timestamp)\n",
        "\n",
        "#Lets create a function to plot pred vs truth\n",
        "def plot_predictions1(model, X, y, start=0, end=100):\n",
        "  predictions = model.predict(X).flatten()\n",
        "  df = pd.DataFrame(data={'Predictions':predictions, 'Actuals':y})\n",
        "  plt.plot(df['Predictions'][start:end])\n",
        "  plt.plot(df['Actuals'][start:end])\n",
        "  return df, mse(y, predictions)\n",
        "\n",
        "# Definign the cyclical nature of time with Day/Year sin and cos.\n",
        "day = 60*60*24\n",
        "year = 365.2425*day\n",
        "\n",
        "temp_df['Day sin'] = np.sin(temp_df['Seconds'] * (2* np.pi / day))\n",
        "temp_df['Day cos'] = np.cos(temp_df['Seconds'] * (2 * np.pi / day))\n",
        "temp_df['Year sin'] = np.sin(temp_df['Seconds'] * (2 * np.pi / year))\n",
        "temp_df['Year cos'] = np.cos(temp_df['Seconds'] * (2 * np.pi / year))\n",
        "temp_df.head()\n",
        "\n",
        "# Get rid of seconds... monotonous increasing\n",
        "temp_df = temp_df.drop('Seconds', axis=1)\n",
        "temp_df.head()\n",
        "\n",
        "# Adding additional pressure feature\n",
        "p_temp_df = pd.concat([df['p (mbar)'], temp_df], axis=1)\n",
        "p_temp_df.head()\n",
        "\n",
        "# Processing the data for network\n",
        "def df_to_X_y3(df, window_size=7):\n",
        "  df_as_np = df.to_numpy()\n",
        "  X = []\n",
        "  y = []\n",
        "  for i in range(len(df_as_np)-window_size):\n",
        "    row = [r for r in df_as_np[i:i+window_size]]\n",
        "    X.append(row)\n",
        "    label = [df_as_np[i+window_size][0], df_as_np[i+window_size][1]]\n",
        "    y.append(label)\n",
        "  return np.array(X), np.array(y)\n",
        "\n",
        "X3, y3 = df_to_X_y3(p_temp_df)\n",
        "X3.shape, y3.shape\n",
        "\n",
        "X3_train, y3_train = X3[:60000], y3[:60000]\n",
        "X3_val, y3_val = X3[60000:65000], y3[60000:65000]\n",
        "X3_test, y3_test = X3[65000:], y3[65000:]\n",
        "X3_train.shape, y3_train.shape, X3_val.shape, y3_val.shape, X3_test.shape, y3_test.shape\n",
        "\n",
        "# Standardize the data, as the span of all inputs vary signinficatly, thus it may mess with the cost function\n",
        "temp_training_mean3 = np.mean(X3_train[:, :, 1])\n",
        "temp_training_std3 = np.std(X3_train[:, :, 1])\n",
        "\n",
        "p_training_mean3 = np.mean(X3_train[:, :, 0])\n",
        "p_training_std3 = np.std(X3_train[:, :, 0])\n",
        "\n",
        "def preprocess3(X):\n",
        "  X[:, :, 0] = (X[:, :, 0] - p_training_mean3) / p_training_std3\n",
        "  X[:, :, 1] = (X[:, :, 1] - temp_training_mean3) / temp_training_std3\n",
        "\n",
        "def preprocess_output3(y):\n",
        "  y[:, 0] = (y[:, 0] - p_training_mean3) / p_training_std3\n",
        "  y[:, 1] = (y[:, 1] - temp_training_mean3) / temp_training_std3\n",
        "  return y\n",
        "\n",
        "preprocess3(X3_train)\n",
        "preprocess3(X3_val)\n",
        "preprocess3(X3_test)\n",
        "\n",
        "#Defining Model Architecture\n",
        "model5 = Sequential()\n",
        "model5.add(InputLayer((7, 6)))\n",
        "model5.add(LSTM(64))\n",
        "model5.add(Dense(8, 'relu'))\n",
        "model5.add(Dense(2, 'linear'))\n",
        "\n",
        "model5.summary()\n",
        "\n",
        "def plot_predictions2(model, X, y, start=0, end=100):\n",
        "  predictions = model.predict(X)\n",
        "  p_preds, temp_preds = predictions[:, 0], predictions[:, 1]\n",
        "  p_actuals, temp_actuals = y[:, 0], y[:, 1]\n",
        "  df = pd.DataFrame(data={'Temperature Predictions': temp_preds,\n",
        "                          'Temperature Actuals':temp_actuals,\n",
        "                          'Pressure Predictions': p_preds,\n",
        "                          'Pressure Actuals': p_actuals\n",
        "                          })\n",
        "  plt.plot(df['Temperature Predictions'][start:end])\n",
        "  plt.plot(df['Temperature Actuals'][start:end])\n",
        "  plt.plot(df['Pressure Predictions'][start:end])\n",
        "  plt.plot(df['Pressure Actuals'][start:end])\n",
        "  return df[start:end]\n",
        "\n",
        "# Train Model\n",
        "model5.fit(X3_train, y3_train, validation_data=(X3_val, y3_val), epochs=10, callbacks=[cp5])\n",
        "plot_predictions2(model5, X3_test, y3_test)\n",
        "#Call backs\n",
        "cp4 = ModelCheckpoint('model4/', save_best_only=True)\n",
        "model4.compile(loss=MeanSquaredError(), optimizer=Adam(learning_rate=0.0001), metrics=[RootMeanSquaredError()])\n",
        "\n",
        "def postprocess_temp(arr):\n",
        "  arr = (arr*temp_training_std3) + temp_training_mean3\n",
        "  return arr\n",
        "\n",
        "def postprocess_p(arr):\n",
        "  arr = (arr*p_training_std3) + p_training_mean3\n",
        "  return arr\n",
        "\n",
        "def plot_predictions2(model, X, y, start=0, end=100):\n",
        "  predictions = model.predict(X)\n",
        "  p_preds, temp_preds = postprocess_p(predictions[:, 0]), postprocess_temp(predictions[:, 1])\n",
        "  p_actuals, temp_actuals = postprocess_p(y[:, 0]), postprocess_temp(y[:, 1])\n",
        "  df = pd.DataFrame(data={'Temperature Predictions': temp_preds,\n",
        "                          'Temperature Actuals':temp_actuals,\n",
        "                          'Pressure Predictions': p_preds,\n",
        "                          'Pressure Actuals': p_actuals\n",
        "                          })\n",
        "  plt.plot(df['Temperature Predictions'][start:end])\n",
        "  plt.plot(df['Temperature Actuals'][start:end])\n",
        "  plt.plot(df['Pressure Predictions'][start:end])\n",
        "  plt.plot(df['Pressure Actuals'][start:end])\n",
        "  return df[start:end]\n",
        "post_processed_df = plot_predictions2(model5, X3_test, y3_test)\n",
        "post_processed_df\n"
      ],
      "metadata": {
        "id": "Y4_8Zdlyd-xU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "># **Largely the work flow would be:**\n",
        "\n",
        ">Store the data from CSV/or whatever to a Pandas data frame\n",
        ">> `df = pd.read_csv(csv_path)`\n",
        "\n",
        "> Splice the data in training , validation and testing data sets.\n",
        "\n",
        "> Reshape the data according to required window size and dim.\n",
        ">> Example: here df's all collums are treated as input features.\n",
        "```\n",
        "def df_to_X_y3(df, window_size=7):\n",
        "  df_as_np = df.to_numpy()\n",
        "  X = []\n",
        "  y = []\n",
        "  for i in range(len(df_as_np)-window_size):\n",
        "    row = [r for r in df_as_np[i:i+window_size]]\n",
        "    X.append(row)\n",
        "    label = [df_as_np[i+window_size][0], df_as_np[i+window_size][1]] # Features\n",
        "    y.append(label)\n",
        "  return np.array(X), np.array(y)\n",
        "```\n",
        "\n",
        "> Standardize the data (preprocess the data )\n",
        ">> Data_standardized = (Data-mean(data))/standard devation of data\n",
        "```\n",
        "def preprocess(X):\n",
        "  X[:, :, 0] = (X[:, :, 0] - p_training_mean3) / p_training_std3\n",
        "  X[:, :, 1] = (X[:, :, 1] - temp_training_mean3) / temp_training_std3\n",
        "def preprocess_output(y):\n",
        "  y[:, 0] = (y[:, 0] - p_training_mean3) / p_training_std3\n",
        "  y[:, 1] = (y[:, 1] - temp_training_mean3) / temp_training_std3\n",
        "  return y\n",
        "```\n",
        "\n",
        "> Define the Network Architecture, example:\n",
        "```\n",
        "model5 = Sequential()\n",
        "model5.add(InputLayer((7, 6))) # R = 7 window width, C = 6 no. of features\n",
        "model5.add(LSTM(64))\n",
        "model5.add(Dense(8, 'relu'))\n",
        "model5.add(Dense(2, 'linear'))\n",
        "model5.summary()\n",
        "```\n",
        "> Train the model with apt callbacks\n",
        "\n",
        ">Post process the output:\n",
        ">> Scale the predicted output back to physical quantities\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "QJa4MWkMgN3V"
      }
    }
  ]
}