temperature_forecasting_time_series.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/avimonda298/NLP/blob/main/temperature_forecasting_time_series.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jdneRZu9b6LV"
      },
      "outputs": [],
      "source": [
        "# Last amended: 10th Feb, 2023\n",
        "# My folder: /home/ashok/Documents/14.sensor_data\n",
        "# VM: lubuntu_deeplearning_I.vdi\n",
        "# Ref: Page 207, Chapter 6, Deep Learning with Python by Fracois Chollete\n",
        "# Download dataset from:\n",
        "# 1. Link to my google drive\n",
        "#  https://drive.google.com/file/d/1rnhlFKmmmhXqawaIBgjSTsqGrTLCUldV/view?usp=sharing\n",
        "# 2. Link to original datasource\n",
        "#  https://s3.amazonaws.com/keras-datasets/jena_climate_2009_2016.csv.zip"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Objectives:\n",
        "#             i)  Working with timeseries data\n",
        "#             i)  Working with sensor data\n",
        "#                 (Data comes from many sensors)\n",
        "#             ii) Processing data to make it fit for modeling\n",
        "#            iii) Creating data generator(s) for training and validation\n",
        "#            iv)  Making predictions using\n",
        "#                   a) Fully connected dense model\n",
        "#                   b) GRU model\n",
        "#                   c) GRU model with dropouts\n",
        "#                   d) Stacked GRU models\n",
        "#                   e) Bidirectional RNN layer\n",
        "#\n",
        "#"
      ],
      "metadata": {
        "id": "huq-vVpRcH4X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Task"
      ],
      "metadata": {
        "id": "NJ616xsmcMxP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# We will predict temperature:\n",
        "# Sensor data is recorded every 10 minutes. So per-day we have:\n",
        "#   no of minutes:              24 * 60     =  1440\n",
        "#   no of 10 minutes interval: (24 * 60)/10 = 144 datapoints/per day\n",
        "#   no of data-points in 10 days: 1440"
      ],
      "metadata": {
        "id": "gdWgLHxRcL6_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#   Our Data\n",
        "#   This is the data from csv file in notepad++\n",
        "#   Note each col-header is a string\n",
        "#   but each col value is NOT. \n",
        "#   First col is date-time\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "\"Date Time\",\"p (mbar)\",\"T (degC)\",\"Tpot (K)\",\"Tdew (degC)\",\"rh (%)\",\"VPmax (mbar)\",\"VPact (mbar)\",\"VPdef (mbar)\",\"sh (g/kg)\",\"H2OC (mmol/mol)\",\"rho (g/m**3)\",\"wv (m/s)\",\"max. wv (m/s)\",\"wd (deg)\"\n",
        "01.01.2009 00:10:00,996.52,-8.02,265.40,-8.90,93.30,3.33,3.11,0.22,1.94,3.12,1307.75,1.03,1.75,152.30\n",
        "01.01.2009 00:20:00,996.57,-8.41,265.01,-9.28,93.40,3.23,3.02,0.21,1.89,3.03,1309.80,0.72,1.50,136.10\n",
        "01.01.2009 00:30:00,996.53,-8.51,264.91,-9.31,93.90,3.21,3.01,0.20,1.88,3.02,1310.24,0.19,0.63,171.60\n",
        "\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "iBXW2J6koj8P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Call libraries"
      ],
      "metadata": {
        "id": "q5YGPiuocaeX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.0 Reset all variables\n",
        "#%reset -f\n",
        "\n",
        "# 1.0 Call libraries:\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras import layers\n",
        "from tensorflow.keras.optimizers import RMSprop\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import os, time, gc, pathlib"
      ],
      "metadata": {
        "id": "GfcUriAvcZnA"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.0.1 Display multiple outputs from a cell:\n",
        "\n",
        "from IPython.core.interactiveshell import InteractiveShell\n",
        "InteractiveShell.ast_node_interactivity = \"all\"\n"
      ],
      "metadata": {
        "id": "9e-hx8pfdkcu"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Mount gdrive"
      ],
      "metadata": {
        "id": "IJx0do-PTlT8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.1 Mount gdrive:\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/gdrive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pr3N9CPyTkkU",
        "outputId": "725827d8-90ce-47e8-d064-72b6b42baecc"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /gdrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## How to read csv data without pandas\n",
        "Open & read csv file; split at '\\n', and then at ',' and finally transform to numpy array.<br>\n",
        "`\n",
        ">open(path)<br>\n",
        ">f.read()<br>\n",
        ">f.close()<br>\n",
        ">data.split('\\n')<br>\n",
        ">lines.split(',')<br>\n",
        "`"
      ],
      "metadata": {
        "id": "a4csnTjzchOX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.1 Where is my data folder?\n",
        "data_dir = '/gdrive/MyDrive/Colab_data_files/climate'\n",
        "\n",
        "# 1.1.0 Make data_dir a pathlib object:\n",
        "\n",
        "folderPath = pathlib.Path(data_dir)"
      ],
      "metadata": {
        "id": "Bn10kSZUcndP"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.2 Join datapath with filename (intelligently)\n",
        "#     If you are on Windows, assign to fname full\n",
        "#     data path+ filename:\n",
        "\n",
        "fname = os.path.join(data_dir, 'jena_climate.csv')\n",
        "fname"
      ],
      "metadata": {
        "id": "krnBJRr2cjV4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "381c4d00-c58b-4580-81ea-35319f3b0144"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'/gdrive/MyDrive/Colab_data_files/climate/jena_climate.csv'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.2 Get filename:\n",
        "\n",
        "fname = folderPath / 'jena_climate.csv'"
      ],
      "metadata": {
        "id": "JGAKvCFkQem-"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.3 Read datafile, line by line\n",
        "# 1.3.1 First get a handle to file:\n",
        "\n",
        "f = open(fname)   # open() default mode is text+read\n",
        "\n",
        "# 1.3.2 Use handle to read complete file\n",
        "data = f.read()"
      ],
      "metadata": {
        "id": "t_9bPtUhcu74"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.3.3 Close read file:\n",
        "\n",
        "f.close()"
      ],
      "metadata": {
        "id": "LosNIABzctNX"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Observe read file data\n",
        "Basic python operations on file"
      ],
      "metadata": {
        "id": "v6RnleSAc5Fp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.3.4 Check data type:\n",
        "#       It is one string:\n",
        "\n",
        "assert type(data) is str\n",
        "\n",
        "print(\"\\n====\\n\")\n",
        "\n",
        "type(data) #  str"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GSK9UZtIVLRL",
        "outputId": "5835af7f-f68b-42a7-95bb-300bfeee8f9d"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "====\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.3.5 Observe Ist 220 chars of data string:\n",
        "#       Also see '\\n' char in between:\n",
        "\n",
        "data[0:220]      # Whole data is read as one string\n",
        "                 # Read first 200 characters of string\n",
        "                 # Note '\\n' at 196th character\n"
      ],
      "metadata": {
        "id": "wyz-ctvnc7xt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "424fa801-c4fd-4bad-af76-29d9a6c412f0"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\"Date Time\",\"p (mbar)\",\"T (degC)\",\"Tpot (K)\",\"Tdew (degC)\",\"rh (%)\",\"VPmax (mbar)\",\"VPact (mbar)\",\"VPdef (mbar)\",\"sh (g/kg)\",\"H2OC (mmol/mol)\",\"rho (g/m**3)\",\"wv (m/s)\",\"max. wv (m/s)\",\"wd (deg)\"\\n01.01.2009 00:10:00,996.'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.4 Process string:\n",
        "\n",
        "# 1.4.1 Split data on newline (\\n). So how many records?\n",
        "\n",
        "lines = data.split('\\n')    # Split data 'str' at every 'newline'\n",
        "                            # and collect the str(s) in a list\n",
        "print(\"\\n=====\\n\")\n",
        "\n",
        "type(lines)                 # list =>  All splits are in one list\n",
        "print(\"\\n=====\\n\")\n",
        "len(lines)                  # Total splits/elements are 420552\n",
        "print(\"\\n=====\\n\")\n",
        "lines[3]                    # Just print some element of list\n",
        "\n"
      ],
      "metadata": {
        "id": "Ekk9kqTGdChv",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 215
        },
        "outputId": "c734e92f-9426-4306-812f-2581067cf718"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=====\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 14
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=====\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "420552"
            ]
          },
          "metadata": {},
          "execution_count": 14
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=====\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'01.01.2009 00:30:00,996.53,-8.51,264.91,-9.31,93.90,3.21,3.01,0.20,1.88,3.02,1310.24,0.19,0.63,171.60'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.4.2 Does any header exist? Check:\n",
        "lines[0]                   # yes, it does\n",
        "\n",
        "print(\"\\n=====\\n\")\n",
        "\n",
        "lines[1]                  # Contains data"
      ],
      "metadata": {
        "id": "2S5fHG7ldv_o",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        },
        "outputId": "fa74b691-a53b-411b-ead3-7ac1daa237ea"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\"Date Time\",\"p (mbar)\",\"T (degC)\",\"Tpot (K)\",\"Tdew (degC)\",\"rh (%)\",\"VPmax (mbar)\",\"VPact (mbar)\",\"VPdef (mbar)\",\"sh (g/kg)\",\"H2OC (mmol/mol)\",\"rho (g/m**3)\",\"wv (m/s)\",\"max. wv (m/s)\",\"wd (deg)\"'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 15
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=====\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'01.01.2009 00:10:00,996.52,-8.02,265.40,-8.90,93.30,3.33,3.11,0.22,1.94,3.12,1307.75,1.03,1.75,152.30'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.4.3 Extract header (field-names)\n",
        "header = lines[0].split(',')  # Split at each ','\n",
        "\n",
        "header  # A list of strs AND within each string is a string"
      ],
      "metadata": {
        "id": "_nNljWDtdzWP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "277602ee-67a7-4ef3-aac9-60a4b2107edb"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['\"Date Time\"',\n",
              " '\"p (mbar)\"',\n",
              " '\"T (degC)\"',\n",
              " '\"Tpot (K)\"',\n",
              " '\"Tdew (degC)\"',\n",
              " '\"rh (%)\"',\n",
              " '\"VPmax (mbar)\"',\n",
              " '\"VPact (mbar)\"',\n",
              " '\"VPdef (mbar)\"',\n",
              " '\"sh (g/kg)\"',\n",
              " '\"H2OC (mmol/mol)\"',\n",
              " '\"rho (g/m**3)\"',\n",
              " '\"wv (m/s)\"',\n",
              " '\"max. wv (m/s)\"',\n",
              " '\"wd (deg)\"']"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.4.4 How many columns/fields?\n",
        "\n",
        "cols = len(header)\n",
        "cols             # 15"
      ],
      "metadata": {
        "id": "-k13-XlDd2Gn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0d82417d-a63a-4477-8e71-af3adf1bfaf8"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "15"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.4.5 Print first three rows.\n",
        "#       Note 10-minute gap in the\n",
        "#       observations:\n",
        "\n",
        "lines[1:4]     # A list of 3 string elements\n",
        "\n",
        "print(\"\\n======\\n\")\n",
        "\n",
        "len(lines)    # 420552 or header + 420551 data points"
      ],
      "metadata": {
        "id": "znBS9A3Ed3Um",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81f285f8-55d6-4cc8-e556-96f732210c3b"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['01.01.2009 00:10:00,996.52,-8.02,265.40,-8.90,93.30,3.33,3.11,0.22,1.94,3.12,1307.75,1.03,1.75,152.30',\n",
              " '01.01.2009 00:20:00,996.57,-8.41,265.01,-9.28,93.40,3.23,3.02,0.21,1.89,3.03,1309.80,0.72,1.50,136.10',\n",
              " '01.01.2009 00:30:00,996.53,-8.51,264.91,-9.31,93.90,3.21,3.01,0.20,1.88,3.02,1310.24,0.19,0.63,171.60']"
            ]
          },
          "metadata": {},
          "execution_count": 18
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "======\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "420552"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1.4.6 Total samples?\n",
        "\n",
        "totalsamples = len(lines) - 1    # 420551 (exclude header)\n",
        "totalsamples"
      ],
      "metadata": {
        "id": "YL-5VnyXe57C",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0e3b15cb-f9da-43aa-93d2-ec2945e652af"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "420551"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Populating numpy array with data\n",
        "Transform our `lines` to numpy array<br>\n",
        "`\n",
        ">`create zero-filled array`<br>\n",
        "` for ith line in lines`<br>\n",
        ">>  fill $i^{th}$ np.array() with i.split(',')<br>\n",
        "`"
      ],
      "metadata": {
        "id": "OelYdZt_faYI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.0 Convert all 420551 data points into a numpy array\n",
        "#     for processing\n",
        "\n",
        "# 2.1 First create a zero-valued 2D-array\n",
        "#      While creating zero-valued 2D-array, forget\n",
        "#        first column or time col\n",
        "#     So array size will be same as that of data\n",
        "\n",
        "float_data = np.zeros(\n",
        "                       (totalsamples, cols -1 )   # Exclude 1st date/time col\n",
        "                      )  \n",
        "\n",
        "float_data.shape           # (420551,14)"
      ],
      "metadata": {
        "id": "-R-Z8gDAfYaw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "496e76d5-ed01-420c-85e0-c43ba592ccb6"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(420551, 14)"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.2 Fill this 2D-zero-valued array, row-by-row using for-loop\n",
        "# 2.2.1 First get an array of 420551 values\n",
        "#       0 ,1, 2, 3,...420550\n",
        "\n",
        "numbList=np.arange(float_data.shape[0])\n",
        "numbList"
      ],
      "metadata": {
        "id": "tsERnYczuQbW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37f2da26-3663-4e6d-ecdb-da1214ef1fff"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([     0,      1,      2, ..., 420548, 420549, 420550])"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.2.2 See how a line is split in respective\n",
        "#       field values. We want split values to\n",
        "#       be an array. But after the split,\n",
        "#       they are a list\n",
        "\n",
        "x = lines[1].split(',')\n",
        "type(x)      # list"
      ],
      "metadata": {
        "id": "0qAOPV4DuVPI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b8fa6683-eaf9-4f18-b98e-364a839131d3"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.2.3 Transform x, a list, into numpy array:\n",
        "#\n",
        "\n",
        "x = np.asarray(\n",
        "               x[1:],     # list\n",
        "               dtype = 'float32'\n",
        "               ) # Exclude 1st date/time column\n",
        "\n",
        "type(x)\n",
        "print(\"\\n======\\n\")\n",
        "x\n",
        "print(\"\\n======\\n\")\n",
        "x.shape"
      ],
      "metadata": {
        "id": "1C-ZOWUZuYaZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0f893318-c37f-4004-a378-2fece5bfc346"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "numpy.ndarray"
            ]
          },
          "metadata": {},
          "execution_count": 23
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "======\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 9.96520e+02, -8.02000e+00,  2.65400e+02, -8.90000e+00,\n",
              "        9.33000e+01,  3.33000e+00,  3.11000e+00,  2.20000e-01,\n",
              "        1.94000e+00,  3.12000e+00,  1.30775e+03,  1.03000e+00,\n",
              "        1.75000e+00,  1.52300e+02], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "======\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(14,)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.3  Fill up zero-array,row-by-row, with sensor data\n",
        "for i in numbList:      # ie uptil the last line\n",
        "    \n",
        "    # 2.3.0 Now do this for all lines using for-loop\n",
        "    row_list = lines[i+1].split(',')     # i starts from 0 but we ignore header\n",
        "\n",
        "    # 2.3.1 'row' is a list. Select all but 1st element\n",
        "    row_list= row_list[1:]                    # Ignore the date column\n",
        "    \n",
        "    # 2.3.2\n",
        "    values = np.asarray(row_list, dtype = 'float32')\n",
        "    \n",
        "    # 2.3.3\n",
        "    float_data[i, :] = values       # Fill zero-array, row-by-row"
      ],
      "metadata": {
        "id": "HBIhlrsWuxSu"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 2.3.4 Check\n",
        "float_data.shape     # (420551,14)\n",
        "\n",
        "print(\"\\n======\\n\")\n",
        "\n",
        "# 2.3.5\n",
        "float_data[0]"
      ],
      "metadata": {
        "id": "iJzNzYHwu4cC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3ee39d4e-f510-4547-f833-54d87ecafd2b"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(420551, 14)"
            ]
          },
          "metadata": {},
          "execution_count": 25
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "======\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 9.96520020e+02, -8.02000046e+00,  2.65399994e+02, -8.89999962e+00,\n",
              "        9.33000031e+01,  3.32999992e+00,  3.10999990e+00,  2.19999999e-01,\n",
              "        1.94000006e+00,  3.11999989e+00,  1.30775000e+03,  1.02999997e+00,\n",
              "        1.75000000e+00,  1.52300003e+02])"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Plotting temperature"
      ],
      "metadata": {
        "id": "vo-sMzg8u7oB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 3. Let us plot temperature, the IInd column\n",
        "#    Check 'header', if you like\n",
        "# 3.1 Get IInd column with index 1\n",
        "temp = float_data[:, 1]\n",
        "temp"
      ],
      "metadata": {
        "id": "4DOm1N_-u9ho",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5332113b-9b7c-4499-8d91-2f1a5f5860b0"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-8.02000046, -8.40999985, -8.51000023, ..., -3.16000009,\n",
              "       -4.23000002, -4.82000017])"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3.2 plot it. It is highly periodic\n",
        "plt.plot(range(len(temp)), temp) ;\n",
        "plt.show() ; "
      ],
      "metadata": {
        "id": "db3aC1udvOVC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "outputId": "9f522cd2-e362-4ab7-d979-698344150e8a"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3.3 Let us see 12-hour variation\n",
        "#     How many readings in one-day?  (24 * 60 )/10 = 144\n",
        "#     So half day = 72 points\n",
        "#     It is half of this variation we want to predict\n",
        "\n",
        "plt.plot(range((12*60//10)), temp[:72]) ;\n",
        "plt.show() ; "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "UnbNSH-8iS4c",
        "outputId": "1e376aff-dd4b-4f9b-c281-ce9ed2e567f6"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 3.4 Delete unwanted variable\n",
        "del temp\n",
        "gc.collect()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d-bgpYnziTSl",
        "outputId": "24c36f58-e0c8-4a05-eead-abda328c647b"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4879"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Standardize data"
      ],
      "metadata": {
        "id": "_2xA237SjIyA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "### Data pre-processing\n",
        "###---------------\n",
        "# 4.0 For processing we center and scale all data\n",
        "#     Could have used sklearn's StandardScaler()\n",
        "#     We decide upon a max sample size of 2 lakh\n",
        "#     Were we rich in memory, more could have been selected\n",
        "\n",
        "training_data_size = 420551     # select 200000 to save memory"
      ],
      "metadata": {
        "id": "YI708UKCivzv"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 4.1   Get column-wise (axis= 0) mean\n",
        "#       We extract mean from training data only but would apply\n",
        "#       to whole of data\n",
        "\n",
        "mean = float_data[:training_data_size].mean(axis = 0)\n",
        "mean[:4]     # Show means of Ist four column means\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cCFs1aC5i-2h",
        "outputId": "a08a579a-3ffe-4b33-8172-f9d4a2b95d31"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([989.21277606,   9.45014735, 283.49274343,   4.95585384])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 4.2  Subtract from each column, its respective mean\n",
        "#      We subtract this from all data.\n",
        "\n",
        "float_data = float_data - mean\n"
      ],
      "metadata": {
        "id": "w0rt9wI3i_Ob"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 4.3   Get std deviation of each column \n",
        "#       but from training data only:\n",
        "\n",
        "std = float_data[:training_data_size].std(axis = 0)\n",
        "std[:4]    # First four column std deviation"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M8WR30HTjkfq",
        "outputId": "87d35344-ab64-4afe-fcac-1245980f9401"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([8.35847079, 8.4233552 , 8.50446129, 6.73066631])"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 4.4 Divide each column by its respective std deviation:\n",
        "\n",
        "float_data /= std\n",
        "float_data.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ANKDSQ3ylSfI",
        "outputId": "b7904a52-961d-44f8-8127-c1cba7033d93"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(420551, 14)"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Create data generators\n",
        "Explanation"
      ],
      "metadata": {
        "id": "fUsWkBcb8Jat"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "################## Learning to create data generators ###############\n",
        "##################### Expt & explanation #############################\n",
        "## 5.0 Problem defined:\n",
        "## --------------------\n",
        "## Starting from any point, say, i, in dataset, our intention is\n",
        "##  to lookback 1440 timesteps (24*60/10=144/day; 10days) behind,  \n",
        "##   and using this data, predict temp one day ahead of i ie 144 \n",
        "##    time steps ahead of i.\n",
        "##    Instead of considering all 1440 lookback points, we will sample\n",
        "##     one point per hour or just 24 datapoints/day for 10 days ie \n",
        "##      total= (24 * 10) data points of lookback. \n",
        "##\n"
      ],
      "metadata": {
        "id": "BG4zV_9Xln6s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "## Train Data Generator\n",
        "## ---------------------\n",
        "## 5.1 Case 1: How will we generate our training data?\n",
        "##  Pick any random index, i, and then we will generate \n",
        "##    our data. Let us randomly pick index,i, as: 1742.\n",
        "##     We go back lookback pts ie 1742 - 1440 = 302 and\n",
        "##      pick every index after each 'step' (=6):\n",
        "##        Batch 1 (240 observations)\n",
        "##                (14 attributes + target)\n",
        "##    index   pressure     temp    humidity        Target\n",
        "##    302     0.87        0.1     0.23             0.17\n",
        "##    308     0.28        0.91    0.77             0.63\n",
        "##    314     0.56        0.33    0.99             0.45\n",
        "##    320       ..           ..      ..\n",
        "##              ..           ..      ..\n",
        "##    1742    0.86        0.09    0.13             0.21\n",
        "##    last index: 302 + (step * 240)\n",
        "\n",
        "##  5.1.1 Per epoch, we will pick 128 random indices (i(s)) & then generate\n",
        "##         128 batches of data (steps_per_epoch = 128). Our data generator\n",
        "##          can generate infinite batches of data, epoch-after-epoch. While\n",
        "##           picking 128 random i(s) we will take care that i-1440 > min_index\n",
        "##            And i + delay < max_index\n",
        "##"
      ],
      "metadata": {
        "id": "499rejNu8o3B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "##  5.1.2 We will have heve 128 batches of (each batch: 240 X 14) datasets. \n",
        "##        For training data, all our 128 batches will be picked up randomly\n",
        "##        from first 2 lakh data points. We select some arbitrary points\n",
        "##        (arbitrary Xs) within our data and proceed sequentially to pick up\n",
        "#         240 rows."
      ],
      "metadata": {
        "id": "JIkYpGi6rvQV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "##  5.1.3 We will make random selection of 128 points many\n",
        "##        times (infinitely) in our training-data-generator (steps_per_epoch).\n",
        "##        This will help in changing the sequence of time steps."
      ],
      "metadata": {
        "id": "DhgrXnftsbQ8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "## 5.2 Validation data Generator\n",
        "## -----------------------------\n",
        "##  For validation data, we start with min_index = 200001 and limit max_index = 300000.\n",
        "##  This time we will NOT pick up batches randomly but sequentially. We start with \n",
        "##   200001 + lookback = 200001 + 1440 = 2001441 and get 128 row-numbers \n",
        "##     (including 2001441) sequentially that is: 201441, 201442,...201568 \n",
        "##       ie upto (200001 + 1440 +128 - 1) OR (i + lookback -1 + batch_size ).\n",
        "##        While proceeding throgh these numbers, one by one, we prepare dataset of \n",
        "##         240 points (each point at an interval of 6steps). "
      ],
      "metadata": {
        "id": "KU5Alce-2Qrc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "## 5.3 Test Data generator\n",
        "##  ----------------------------------------------\n",
        "#  Same as for validation but this time min_index = 300001 \n",
        "#   but max_index = None that is upto: len(float_data) - delay - 1."
      ],
      "metadata": {
        "id": "sg1ZvtPWtb_E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Constants"
      ],
      "metadata": {
        "id": "CMVjB72b2rHr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 6.0. Define some common constants:\n",
        "#      timestep : 10 mins\n",
        "\n",
        "lookback = 1440  # timesteps. (same as 10 days) In RNN, we will lookback at\n",
        "                 #            1440 timesteps. Each timestep is 10 minutes.\n",
        "# 6.1\n",
        "step = 6         # Sample after every 'step' timesteps. \n",
        "                 # Per hour we pick one sample\n",
        "                 # And not every 10 minutes that is pick one point after\n",
        "                 #   every 6th point.\n",
        "                 # Per lookback period datapoints will be 1440/6 = 240\n",
        "                 # So our prediction will be based on data of size 240 X 14.\n",
        "# 6.2\n",
        "delay = 144      # timesteps. (same as 24 hours) We will forecast for a temperatue\n",
        "                 # 144 timesteps ahead\n",
        "\n",
        "# 6.3\n",
        "batch_size = 128 # Analyse 'dataset' in batches of 128 considering memory limitations\n",
        "                 # So we will analyse in memory at a time: 128 X 240 X 14"
      ],
      "metadata": {
        "id": "z3t-vLTF2qKQ"
      },
      "execution_count": 35,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Train data generator--demo"
      ],
      "metadata": {
        "id": "_YD3lovgz19w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#############################\n",
        "###### Case 1   Constants for training data generator\n",
        "#############################\n",
        "\n",
        "# Define constants specific to this Case that is training data\n",
        "# 7.0.\n",
        "min_index = 0        # For training, we start from here\n",
        "max_index = 200000   # Our last index-point for training (200001st pt)\n",
        "shuffle = True       # Training batches will be picked up randomly"
      ],
      "metadata": {
        "id": "gtjVG4v23Lhc"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Generate just a batch of pts (128)"
      ],
      "metadata": {
        "id": "MfMKgGvb3dlz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "##******************************************************\n",
        "#  Begin creating batches of datasets--One batch only\n",
        "##******************************************************\n",
        "#           float_data:10 (index: 9),\n",
        "#                delay:6\n",
        "# Therefore, max_index:3  (=9-6)\n",
        "#        OR, (10 - 1 - 6) \n",
        "\n",
        "\n",
        "# 7.1 Our 'i' should be between min_index and max_index.\n",
        "if max_index is None:    \n",
        "    max_index = len(float_data) - delay - 1   # (200000 - 1) - 144 = 199855\n",
        "\n",
        "# 7.1.1\n",
        "max_index"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eDjMyrx23TJL",
        "outputId": "fa2b7249-1d0d-4213-a79d-5885968d63f7"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "200000"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 7.2 And from where to begin creating lookback batches:\n",
        "\n",
        "i = min_index + lookback     # Begin here to pick up earlier points\n",
        "i                            # Start index\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H-di8f_d3bQ-",
        "outputId": "9bcfbcc8-2aba-456e-e4ef-e871a05e9c55"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1440"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 7.3\n",
        "\n",
        "i      # 1440 timesteps to start with or 10 days lookback\n",
        "       # If this is time, t, RNN gets data for t-1,\n",
        "       #  t-2, right upto first point as lookback is 1440 timesteps\n",
        "       # np.random.randint(low, high, howmany)\n",
        "       # np.random.randint(0,100,10)   Gives 10 random points"
      ],
      "metadata": {
        "id": "23tJ_U8b4DRO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4003f5db-1fe9-461e-9cfd-6cb1520d0077"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1440"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 7.4  How to get one set of 128 index-pts \n",
        "#        from where to lookback and pick up data of 240 X 14\n",
        "\n",
        "if shuffle:               # For training only\n",
        "    # Generate 128 random points (is) for picking training datasets\n",
        "\n",
        "    #                             1440              199855           128\n",
        "    rows = np.random.randint(min_index + lookback, max_index, size=batch_size) \n",
        "\n",
        "else:                      # for validation/test datasets\n",
        "    # Else, generate 128 sequential points:\n",
        "    if i + batch_size >= max_index:   # Given some 'i', if it exceeds limit\n",
        "        i = min_index + lookback      #  then set it to min possible\n",
        "    \n",
        "    rows = np.arange(i, min(i + batch_size, max_index))  # Get a list of all\n",
        "                                                         #  points from i uptill the limit\n",
        "    i += len(rows)      # Increment i by batch_size (128). \n",
        "                        # Next batch pick-up pt is 128 ahead"
      ],
      "metadata": {
        "id": "s6Wt5QDJ4xdO"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 7.5 Have a look at rows from where to \n",
        "#      start picking up 240 lookback points:\n",
        "\n",
        "rows\n",
        "print(\"\\n=====\\n\")\n",
        "\n",
        "min(rows)    # min index\n",
        "print(\"\\n=====\\n\")\n",
        "\n",
        "max(rows)    # max index\n",
        "\n",
        "print(\"\\n=====\\n\")\n",
        "len(rows)    # 128 points"
      ],
      "metadata": {
        "id": "Lle2E7594yHb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d1a3e480-8d1c-41d1-e661-94b760b8c710"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([124357, 144225,  31624,  13068, 162704,  13364,  64610, 131665,\n",
              "       151338, 122718, 192460, 107199, 108743,  50728,  50294, 119681,\n",
              "        28490,   5324,  49489,  91642, 156606, 123381, 183295,  69411,\n",
              "        23267, 138546,  47114,  50091, 196505,  56900, 148835,  31949,\n",
              "        67325, 174950, 189772,  46096, 132635,  26624,  29550,  83065,\n",
              "        83811,  48475,  16377,  30422,  17249,  42463, 173393,  16886,\n",
              "       193469,  28410, 163941,  55804, 100176,  18149, 141910,  36349,\n",
              "        11992,  99386,  84720, 108210, 181857,  90984, 157866, 197122,\n",
              "        62995,  72447, 117662, 107064,  22074,  12746,  53632,  18377,\n",
              "        75676, 145506,  49965, 129050, 198980,  76036,  91834, 117940,\n",
              "        28734, 154673, 177364, 136002,  25686,  57388, 170839,  98346,\n",
              "       172192, 135478, 180465,   9308,  95250, 172916,  51565, 179214,\n",
              "       133883,  28955,  17185,  53566, 109629,  59171,  28103,  19656,\n",
              "       142232, 122265, 145686,  34310, 132042,   2399, 165282, 152975,\n",
              "        69901, 113189,  18495, 133596, 174925,  50539, 146250,  27606,\n",
              "       117836,  12459,  30405,  77590, 154993,  19898,  53829,  84561])"
            ]
          },
          "metadata": {},
          "execution_count": 41
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=====\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2399"
            ]
          },
          "metadata": {},
          "execution_count": 41
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=====\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "198980"
            ]
          },
          "metadata": {},
          "execution_count": 41
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=====\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "128"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 7.6 Given row-points, get samples of datasets, each of 240 X 14\n",
        "#     First, get an array of zeros of requistie batch size:\n",
        "\n",
        "#  3D array          \n",
        "samples = np.zeros(\n",
        "                    (len(rows),             # 128\n",
        "                     lookback // step,      # 240\n",
        "                     float_data.shape[-1])  # 14\n",
        "                    )\n",
        "\n",
        "\n",
        "\n",
        "# 7.7 Check\n",
        "samples.shape   # (128,240,14) (batch size, no_of_points_per_hour, attributes)\n"
      ],
      "metadata": {
        "id": "j7MoPdC-43zo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7f91c8cb-0847-4f31-941f-557327be0fa7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(128, 240, 14)"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Generate a batch of targets for 128 pts"
      ],
      "metadata": {
        "id": "ERH9Bo2ZmH52"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 8.0 There will be as many targets as there are batches:\n",
        "targets = np.zeros((len(rows),))\n",
        "targets = np.zeros((128,))     # same as above\n",
        "targets\n",
        "print(\"\\n==========\\n\")\n",
        "len(targets)    # 128"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1zFFUM9N5zBz",
        "outputId": "54309bd8-d6e2-4b5f-fc51-8cc1ccd94f4f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0.])"
            ]
          },
          "metadata": {},
          "execution_count": 55
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "==========\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "128"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 8.1 Prepare to fill in first batch \n",
        "#     into our 3D zero-array\n",
        "\n",
        "j = 0                 # Later we can loop on this 'j'\n",
        "row = rows[j]         # First point of 128 set taken above\n",
        "row"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tYIUJkWI5zYq",
        "outputId": "ba4c49cd-3f15-4ea3-cc56-0f85528d137a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "88072"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 8.2 Our prediction datapoint is 'delay' timesteps ahead\n",
        "#     And in the data, temperature is at index 1\n",
        "\n",
        "targets[j] = float_data[rows[j] + delay][1]   # Taregt value is the value in IInd column\n",
        "\n",
        "# 8.3                                         #  at the end of rows[j] + delay\n",
        "targets[j]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WXvakOYFtmVO",
        "outputId": "1baebec5-a6e3-4ac2-e6e6-7337667eabfa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.7467158003234955"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Fill in data for each one of 128 batch-pts\n",
        "Go `lookup` pts behind and move ahead by `step`"
      ],
      "metadata": {
        "id": "NaX54przuIqm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 8.4 Whereever I am standing (say at, 1000), I go behind\n",
        "#     'lookback' timesteps (say 100). From there, I proceed\n",
        "#      forward, every 6-datapoints upto where I am standing\n",
        "#       (ie upto 1000). So I collect 240 datapoints:\n",
        "#        Try: indicies = list(range(1000-100, 1000, 6))"
      ],
      "metadata": {
        "id": "Hw-aiP0U6Ez6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#  8.5 Get indices of those 240 datapoints at intervals of 6 (step)\n",
        "#      beginning from  jth index of rows[j]\n",
        "\n",
        "indices = range(rows[j] - lookback, rows[j], step)   # 1440 timesteps values but in steps of 6\n",
        "indices   # range(195492, 196932, 6)\n"
      ],
      "metadata": {
        "id": "EzUGavPw75Xc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f97f529-c426-4189-a13b-27dbcd67e707"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(86632, 88072, 6)"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 8.6\n",
        "print(\"\\n=========\\n\")\n",
        "len(indices)      # total: 240 points\n",
        "print(\"\\n=========\\n\")\n",
        "list(indices)     # What are the points. Spaced at interval of 6"
      ],
      "metadata": {
        "id": "GAJb-r619GCh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 8.7 Finally, fill our zero-sample with data at these indicies:\n",
        "\n",
        "samples[j] = float_data[indices]          # 240 points\n",
        "samples[j].shape                          # 240 X 14\n",
        "print(\"\\n========\\n\")\n",
        "\n",
        "# 8.8 Just have a look\n",
        "samples[j]"
      ],
      "metadata": {
        "id": "9ycRruvTHRrP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "333ec6d6-658d-45aa-d62a-9517393fe420"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(240, 14)"
            ]
          },
          "metadata": {},
          "execution_count": 65
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "========\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[-9.21552098e-01,  1.41034686e+00,  1.47890189e+00, ...,\n",
              "         1.61624219e-02,  3.33751088e-02,  1.09892149e+00],\n",
              "       [-8.65325222e-01,  1.36285989e+00,  1.42598705e+00, ...,\n",
              "         3.34283990e-02,  4.38073409e-02,  9.67405743e-01],\n",
              "       [-7.77983707e-01,  1.23939354e+00,  1.29664246e+00, ...,\n",
              "         1.78431790e-02,  4.72847561e-02,  1.14160659e+00],\n",
              "       ...,\n",
              "       [ 5.73936768e-01,  6.46993049e-01,  5.95834816e-01, ...,\n",
              "         2.22742731e-02,  3.04772616e-02, -1.28024576e+00],\n",
              "       [ 5.34453817e-01,  7.91828592e-01,  7.42816496e-01, ...,\n",
              "        -4.77066321e-03,  1.49883437e-03, -1.87483570e+00],\n",
              "       [ 5.04544040e-01,  9.37851111e-01,  8.89798175e-01, ...,\n",
              "         2.25796448e-03,  1.30902060e-02, -1.56831156e+00]])"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Validation data generator--demo"
      ],
      "metadata": {
        "id": "FlmmnDYlz_MN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#############################\n",
        "###### Case 2   Validation data generator\n",
        "#############################"
      ],
      "metadata": {
        "id": "l0p-CByeHg5H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 9. We will have min_index = 200001 and max_index = 300000 and shuffle = False\n",
        "#    Other constants remain same:\n",
        "\n",
        "min_index = 200001\n",
        "max_index = 300000\n",
        "shuffle = False"
      ],
      "metadata": {
        "id": "i-3PvLs8Hh02"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 9.1   We have to get 128 consecutive points from where to pickup\n",
        "#       128 batches of 240 X 14\n",
        "\n",
        "# 9.1.1 Start here:\n",
        "\n",
        "i = min_index + lookback     # Outside while 1\n",
        "\n",
        "if shuffle:\n",
        "    rows = np.random.randint(min_index + lookback, max_index, size=batch_size)\n",
        "else:\n",
        "    # 9.1.2 Set i\n",
        "    if i + batch_size >= max_index:  # If unable to get list of 128 points ahead\n",
        "                                     #   to get 128 batches of (240 X 14)\n",
        "        i = min_index + lookback     #  start afresh. min_index for validation is 200001\n",
        "    \n",
        "    # 9.1.3\n",
        "    rows = np.arange(i,\n",
        "                     min(i + batch_size, max_index)\n",
        "                     )  # Get a list of all 128 points from i upto limit\n",
        "                                                         \n",
        "   # 9.3.4 Advance i by 128 pts\n",
        "    i += len(rows)                     # Advance i by 128 steps to get next 128 batches"
      ],
      "metadata": {
        "id": "YHE0N5pQHs-0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 10\n",
        "i              # Next batch begins at: 200001 + 1440 + 128 = 201569\n",
        "print(\"\\n===========\\n\")\n",
        "len(rows)                    # 128\n",
        "print(\"\\n===========\\n\")\n",
        "rows           # Just list them"
      ],
      "metadata": {
        "id": "CTSrc6eWH4GX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "908408f9-716b-4745-d4fa-13d97a6ca988"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "201569"
            ]
          },
          "metadata": {},
          "execution_count": 86
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "===========\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "128"
            ]
          },
          "metadata": {},
          "execution_count": 86
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "===========\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([201441, 201442, 201443, 201444, 201445, 201446, 201447, 201448,\n",
              "       201449, 201450, 201451, 201452, 201453, 201454, 201455, 201456,\n",
              "       201457, 201458, 201459, 201460, 201461, 201462, 201463, 201464,\n",
              "       201465, 201466, 201467, 201468, 201469, 201470, 201471, 201472,\n",
              "       201473, 201474, 201475, 201476, 201477, 201478, 201479, 201480,\n",
              "       201481, 201482, 201483, 201484, 201485, 201486, 201487, 201488,\n",
              "       201489, 201490, 201491, 201492, 201493, 201494, 201495, 201496,\n",
              "       201497, 201498, 201499, 201500, 201501, 201502, 201503, 201504,\n",
              "       201505, 201506, 201507, 201508, 201509, 201510, 201511, 201512,\n",
              "       201513, 201514, 201515, 201516, 201517, 201518, 201519, 201520,\n",
              "       201521, 201522, 201523, 201524, 201525, 201526, 201527, 201528,\n",
              "       201529, 201530, 201531, 201532, 201533, 201534, 201535, 201536,\n",
              "       201537, 201538, 201539, 201540, 201541, 201542, 201543, 201544,\n",
              "       201545, 201546, 201547, 201548, 201549, 201550, 201551, 201552,\n",
              "       201553, 201554, 201555, 201556, 201557, 201558, 201559, 201560,\n",
              "       201561, 201562, 201563, 201564, 201565, 201566, 201567, 201568])"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 11. Get a zero-filled array of 128 X 240 X 14\n",
        "#     Now get\n",
        "#     \n",
        "samples = np.zeros(\n",
        "                    (len(rows),              # 128\n",
        "                     lookback // step,       # 240\n",
        "                     float_data.shape[-1])   # 14\n",
        "                    )\n",
        "\n",
        "\n",
        "# 11.0.1\n",
        "samples.shape   # (128,240,14) (batch size, no_of_points_per_hour, attributes)"
      ],
      "metadata": {
        "id": "dRyEZWY5IL78",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fad4377d-647e-4978-8c82-91c7755c9532"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(128, 240, 14)"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 11.1 There will be as many targets as there are batches:\n",
        "\n",
        "targets = np.zeros((len(rows),))\n",
        "targets\n",
        "len(targets)    # 128"
      ],
      "metadata": {
        "id": "5ovs9STvIRWl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e89a081b-bec7-4ab4-c916-cf66e35b757e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
              "       0., 0., 0., 0., 0., 0., 0., 0., 0.])"
            ]
          },
          "metadata": {},
          "execution_count": 88
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "128"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 12. Fill the batch with data:\n",
        "\n",
        "row = rows[0]    # First data point to start first batch from\n",
        "j = 0\n",
        "row              # 201441"
      ],
      "metadata": {
        "id": "xpSPJeupIUzd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "46173c54-1eec-4c37-eb6b-c82005c39dd6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "201441"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 12.1 Whereever I am standing, I go loopback back\n",
        "#      From there, I proceed forward, every 6-datapoints\n",
        "#      So I collect 240 datapoints\n",
        "#  Get indices of those 240 datapoints\n",
        "\n",
        "#                    200001          201441   6\n",
        "indices = range(rows[j] - lookback, rows[j], step)   # 1440 timesteps values but in steps of 6\n",
        "print(\"\\n============\\n\")\n",
        "indices   # rrange(200001, 201441, 6)\n",
        "print(\"\\n============\\n\")\n",
        "len(indices)      # total: 240 points"
      ],
      "metadata": {
        "id": "2POyp6WAIbEu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5780ac6c-a1e3-4eae-e9fc-a070af3ec65d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "============\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(200001, 201441, 6)"
            ]
          },
          "metadata": {},
          "execution_count": 91
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "============\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "240"
            ]
          },
          "metadata": {},
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 12.2\n",
        "samples[j] = float_data[indices]          # 240 points\n",
        "samples[j].shape                          # 240 X 14"
      ],
      "metadata": {
        "id": "QHQjSscRIgkE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d2672297-515a-4e1a-b371-8788efb9ecd6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(240, 14)"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 12.3\n",
        "samples[j]"
      ],
      "metadata": {
        "id": "e0MaxZWeIrpO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c8c261c-1211-40f1-d85b-c5287dc87b39"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 2.12046670e-02,  5.05719228e-01,  5.00590975e-01, ...,\n",
              "         8.36981378e-03,  4.39667468e-03,  3.74430818e-01],\n",
              "       [ 3.67583354e-02,  4.04809274e-01,  3.98292301e-01, ...,\n",
              "        -3.70108872e-03, -1.06721087e-02,  2.05998388e-01],\n",
              "       [ 5.35022610e-02,  2.02989480e-01,  1.97222369e-01, ...,\n",
              "        -1.50080107e-02, -2.74795981e-02,  3.51357868e-01],\n",
              "       ...,\n",
              "       [-4.82478612e-01, -9.85373071e-01, -9.42179895e-01, ...,\n",
              "        -4.92368885e-04, -8.35383304e-03, -1.06640158e-01],\n",
              "       [-5.49476221e-01, -9.31950173e-01, -8.83387224e-01, ...,\n",
              "         1.38704769e-02,  1.61329417e-02,  2.90214515e-01],\n",
              "       [-5.91346988e-01, -9.55693686e-01, -9.04555313e-01, ...,\n",
              "         2.10519007e-02,  1.43942376e-02,  3.06438254e-02]])"
            ]
          },
          "metadata": {},
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 13. Our prediction datapoint is delay timesteps ahead:\n",
        "\n",
        "targets[j] = float_data[rows[j] + delay][1]   # Taregt value is the value in IInd column\n",
        "                                              #  at the end of rows[j] + delay\n",
        "# 13.1\n",
        "targets[0]"
      ],
      "metadata": {
        "id": "tJYxQ6rfIukt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e4d30c55-097a-4caa-f2ca-e8f4cd83ad09"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-0.803735225535884"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# So finally return this sample and target\n",
        "#   yield samples, targets"
      ],
      "metadata": {
        "id": "FMXlhYUwIvym"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Test data generator--demo"
      ],
      "metadata": {
        "id": "4TClAol_0FaV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#############################\n",
        "###### Case 3   Test data generator\n",
        "#############################"
      ],
      "metadata": {
        "id": "R15chj7yI1WB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Generator psuedo-code"
      ],
      "metadata": {
        "id": "Wa9N6qfUxEEr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 14. Finally use all above to define a generator to generate data:\n",
        "###\n",
        "#     For training data: max_index: 200000, min_index: 0,     shuffle: True \n",
        "#     For valid    data:          : 300000, min_index: 200001 shuffle: False\n",
        "#     For test     data:          : None,   min_index: 300001 shuffle: False\n",
        "###\n",
        "\n",
        "## Our generator:\n",
        "#    def generator(min_index, max_index, shuffle):\n",
        "#\n",
        "#       If max_index in None, then\n",
        "#           set max_index = (noOfRowsInData - 1) - delay \n",
        "#\n",
        "#       set start pointer,i, to lookback ahead of min_index   \n",
        "#        i = min_index + lookback\n",
        "#   \n",
        "#        while True:\n",
        "#          ToGet 128 points from where to lookback & pick up data\n",
        "#\t\t   \t\t   For training data:\n",
        "#\t\t\t\t\t      Select 128 random points between (0 + lookback, 200000)\n",
        "#\t\t\t\t     For validation/test data:\n",
        "#               Set pointer to i = 200001 (valid) or 300001 (test) + lookback\n",
        "#\t\t\t\t\t         Get next 128 datapoints sequentially\n",
        "#            Advance pointer by 128 ( i = i +128)\n",
        "#\n",
        "#\t\t \t     Now we have 128 points either for training data or for validation/test data\n",
        "#\t\t\t\t     create zero-array of size 128 X 240 X 14\n",
        "#\t\t   \t\t       Fill each one of the 128 zero-arrays with, 240 X 14 values\n",
        "#          \t Get an array of 128 targets at 'delay' distance\n",
        "#          yield sample, target\n",
        "#\n",
        "# SSSSSSSSSSSSSSSS CORRECT upto here SSSSSSSSSSSSsss"
      ],
      "metadata": {
        "id": "ng6NdIj4I6P1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Full generator code"
      ],
      "metadata": {
        "id": "VXr8G6sv0JFu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def generator(data, lookback, delay, min_index, \n",
        "              max_index,shuffle=False, batch_size=128, step=6):\n",
        "\n",
        "    if max_index is None:       # Only for test data we don't set max_index\n",
        "        max_index = len(data) - delay - 1\n",
        "\n",
        "    # 14.1 min_index = (train)0, (valid)200001, (test)300001\n",
        "    i = min_index + lookback\n",
        "\n",
        "    while 1:\n",
        "        if shuffle:         #14.2 True for train data, False for valid & test data\n",
        "            batch_pts = np.random.randint(min_index + lookback,    # lower limit, min_index = 0\n",
        "                                     max_index,               # Upto here, max_index = 200000\n",
        "                                     size=batch_size          # Select any 128 pts\n",
        "                                     )\n",
        "        else:              #14.3 For validation generator rows are between (200001, 207201)\n",
        "            if i + batch_size >= max_index:\n",
        "                i = min_index + lookback\n",
        "            #14.4 Starting i is 'min_index + lookback'\n",
        "            batch_pts = np.arange(i, min(i + batch_size, max_index))   # No random rows picking\n",
        "                                                                  # Normal length of 'rows'\n",
        "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t                                  #  is batch_size or less\n",
        "\n",
        "            #14.5 Value of this 'i' will be preserved between calls to generator()\n",
        "            i += len(batch_pts)   # Next i for valid and test is 128 distance away\n",
        "\n",
        "        # 14.1 Create empty sample (128 X 240 X 14)\n",
        "        #                      128            240                14\n",
        "        samples = np.zeros((len(batch_pts), lookback // step, data.shape[-1]))\n",
        "        # 14.2 Create 128 empty targets\n",
        "        targets = np.zeros((len(batch_pts),))\n",
        "\n",
        "        # 14.3 For every one of the 128 points...\n",
        "        for j, row in enumerate(batch_pts):\n",
        "            # 14.4 Set read-pointer to 'lookback' behind\n",
        "            #      from this batch_pts[j] and pick next 240 points\n",
        "            #      at intervals of 6 points\n",
        "            indices = range(batch_pts[j] - lookback, batch_pts[j], step)\n",
        "            # 14.5 Get data into our sample\n",
        "            samples[j] = data[indices]\n",
        "            # 14.6 Get targets (temperature: IINd columns).\n",
        "            #      index [1] => IInd column or temperatue column\n",
        "            targets[j] = data[batch_pts[j] + delay][1]\n",
        "        # 14.7 Return objects per call\n",
        "        yield samples, targets\n"
      ],
      "metadata": {
        "id": "jVybiAf4JAw1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 15. Our common constants\n",
        "lookback = 1440\n",
        "step = 6\n",
        "delay = 144\n",
        "batch_size = 128"
      ],
      "metadata": {
        "id": "8pfHRUEPJHWu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Train generator"
      ],
      "metadata": {
        "id": "MyJChMbu0WDt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 16. train data generator\n",
        "train_gen = generator(float_data,\n",
        "                       lookback=lookback,\n",
        "                       delay=delay,\n",
        "                       min_index=0,\n",
        "                       max_index=200000,\n",
        "                       shuffle=True,\n",
        "                       step=step,\n",
        "                       batch_size=batch_size)"
      ],
      "metadata": {
        "id": "NO1RSEs3JKbt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Some expts with train generator"
      ],
      "metadata": {
        "id": "ea53s5Jp5K3A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 16.1 Have a look. Run for-loop twice to see change.\n",
        "for samples, targets in train_gen:\n",
        "    print(targets[0])\n",
        "    print(samples[0])\n",
        "    print(samples[0].shape)\n",
        "    break"
      ],
      "metadata": {
        "id": "eKke64ODJLRQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "28eea40f-f7d2-40af-846e-92178485b67a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.306664191950883\n",
            "[[-0.9945302   1.48039023  1.55415465 ...  0.0208991   0.0391708\n",
            "  -1.81184653]\n",
            " [-0.98256921  1.17528619  1.24960904 ...  0.00332754  0.03743209\n",
            "   1.12084072]\n",
            " [-0.92274966  0.99483548  1.06499919 ...  0.00943939  0.02757942\n",
            "   1.2212082 ]\n",
            " ...\n",
            " [ 0.35379759  1.90777341  1.86458168 ...  0.03480356  0.03685252\n",
            "  -1.45317754]\n",
            " [ 0.32508538  1.95169878  1.91043809 ...  0.04060982  0.0426482\n",
            "  -1.53220238]\n",
            " [ 0.31072927  1.98968835  1.95041668 ...  0.02823332  0.03801165\n",
            "  -1.37219148]]\n",
            "(240, 14)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 16.2\n",
        "a = train_gen\n",
        "\n",
        "# 16.2.1 Get first set of dataset\n",
        "s = next(a)\n",
        "print(\"\\n==============\\n\")\n",
        "type(s)            # Tuple\n",
        "print(\"\\n==============\\n\")\n",
        "s[0].shape         # (128,240,1)\n",
        "print(\"\\n==============\\n\")\n",
        "s[1].shape         # (128,)\n",
        "\n",
        "# 16.2.2 Get next set of dataset\n",
        "t = next(a)\n",
        "print(\"\\n==============\\n\")\n",
        "t[0].shape\n",
        "print(\"\\n==============\\n\")\n",
        "t[1].shape\n"
      ],
      "metadata": {
        "id": "9xYul9vcJRLl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0d95ed86-8a7b-4791-f7ed-4b5cce1f1ef8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "==============\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {},
          "execution_count": 33
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "==============\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(128, 240, 14)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "==============\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(128,)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "==============\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(128, 240, 14)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "==============\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(128,)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Validation generator"
      ],
      "metadata": {
        "id": "MEBEdi9a1T3g"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 17. Validation data generator\n",
        "val_gen = generator(\n",
        "                   float_data,\n",
        "                   lookback=lookback,\n",
        "                   delay=delay,\n",
        "                   min_index=200001,\n",
        "                   max_index= 300000,              # 207201, 300000, 200001 + 1440 *5\n",
        "                   step=step,\n",
        "                   batch_size=batch_size\n",
        "                   )\n"
      ],
      "metadata": {
        "id": "pLchRVc8JR-E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 18 How many times to draw from validation generator\n",
        "#    in order to see all validation data:\n",
        "\n",
        "val_steps = (300000 - 200001 - lookback)    # Instead of 300000-200001 - lookback to save time\n",
        "\n",
        "val_steps        # 98559\n",
        "\n",
        "# At the end of each epoch, validation follows.\n",
        "# These many validation steps, take a long time\n",
        "# for epoch to complete. As time is important\n",
        "# to us, we will limit val_steps to 400, so:\n",
        "\n",
        "# 18.1\n",
        "val_steps = 400"
      ],
      "metadata": {
        "id": "Kkw1xgGLFJs4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "08f51ddd-bf09-49e7-ee3d-4c79c8ecae19"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "98559"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Test generator"
      ],
      "metadata": {
        "id": "3XM6Hbgt1Wue"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 18. Test data generator\n",
        "test_gen = generator(\n",
        "                     float_data,\n",
        "                     lookback=lookback,\n",
        "                     delay=delay,\n",
        "                     min_index=300001,\n",
        "                     max_index=None,\n",
        "                     step=step,\n",
        "                     batch_size=batch_size)"
      ],
      "metadata": {
        "id": "RnJsZtmyJW4e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 20\n",
        "test_steps = (len(float_data) - 300001 - lookback)\n",
        "test_steps\n"
      ],
      "metadata": {
        "id": "ZpfBDSHOJd1m",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "011b8211-3a4d-4d63-faeb-e7f5a6fdc801"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "119110"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Models"
      ],
      "metadata": {
        "id": "N8EIRRj61eHf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Simple Model"
      ],
      "metadata": {
        "id": "8k3dBZqe9jLX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "####################################################\n",
        "## 21. We will work with:\n",
        "#              i) Fully connected model\n",
        "#             ii) GRU model\n",
        "#            iii) GRU model with dropouts\n",
        "#             iv) Stacked GRU models"
      ],
      "metadata": {
        "id": "ooQlcOwrJlEV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "###################################\n",
        "### AA. Fully connected model\n",
        "###################################\n",
        "\n"
      ],
      "metadata": {
        "id": "UNp0GfmWKdcZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 22.1 Model design: Sequential\n",
        "model = tf.keras.Sequential()"
      ],
      "metadata": {
        "id": "G1ClQvJIMbuA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Input layer                              240                14\n",
        "model.add(tf.keras.Input(shape = (lookback // step, float_data.shape[-1])))"
      ],
      "metadata": {
        "id": "7MhDCegzMyyg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 22.2 Flatten data of one batch:\n",
        "#                                        \n",
        "model.add(layers.Flatten())\n",
        "model.summary()        # 240 X 14 = 3360\n"
      ],
      "metadata": {
        "id": "OpD2UriOMpzH",
        "outputId": "39b4a7ed-dfd5-40bf-fb98-67bc9b4cead8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " flatten (Flatten)           (None, 3360)              0         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 0\n",
            "Trainable params: 0\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 22.3 Pass it through first hidden layer\n",
        "model.add(tf.keras.layers.Dense(32, activation='relu'))\n",
        "\n",
        "# 22.4 Pass it through output layer\n",
        "model.add(tf.keras.layers.Dense(1))\n",
        "\n",
        "# 22.5 Compile the model\n",
        "model.compile(\n",
        "             optimizer=RMSprop(),\n",
        "             loss='mae'\n",
        "             )"
      ],
      "metadata": {
        "id": "TUL9k5ryMK34"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 22.6\n",
        "model.summary()"
      ],
      "metadata": {
        "id": "wMmQaACaPs-o",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b34d0218-4107-4b46-c39c-88e4dc4389c4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " flatten (Flatten)           (None, 3360)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 32)                107552    \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 1)                 33        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 107,585\n",
            "Trainable params: 107,585\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 22.7 Fit/train the model\n",
        "#      For steps_per_epoch also refer to StackOverflow\n",
        "#      please refer to complete discussion here:\n",
        "#      https://datascience.stackexchange.com/q/47405\n",
        "\n",
        "start = time.time()\n",
        "history = model.fit_generator(train_gen,\n",
        "                              steps_per_epoch=500, # No of times gen called per epoch\n",
        "                                                   #  Each call to gen yields 128 batches\n",
        "                              epochs=20,\n",
        "                              validation_data=val_gen,\n",
        "                              validation_steps=val_steps,\n",
        "                              verbose = 1)\n",
        "end = time.time()\n",
        "print((end-start)/60)    # 4 mins in Colab\n"
      ],
      "metadata": {
        "id": "_NikbTl4OuVg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "846999c2-b1c4-4b16-dfe8-2267cd1c0754"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-49-d9bf262a5dc7>:3: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
            "  history = model.fit_generator(train_gen,\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "500/500 [==============================] - 13s 25ms/step - loss: 1.0050 - val_loss: 0.3391\n",
            "Epoch 2/20\n",
            "500/500 [==============================] - 12s 25ms/step - loss: 0.3357 - val_loss: 0.3566\n",
            "Epoch 3/20\n",
            "500/500 [==============================] - 14s 27ms/step - loss: 0.2947 - val_loss: 0.3951\n",
            "Epoch 4/20\n",
            "500/500 [==============================] - 15s 29ms/step - loss: 0.2788 - val_loss: 0.3345\n",
            "Epoch 5/20\n",
            "500/500 [==============================] - 12s 24ms/step - loss: 0.2658 - val_loss: 0.3464\n",
            "Epoch 6/20\n",
            "500/500 [==============================] - 14s 28ms/step - loss: 0.2581 - val_loss: 0.3274\n",
            "Epoch 7/20\n",
            "500/500 [==============================] - 13s 27ms/step - loss: 0.2536 - val_loss: 0.3293\n",
            "Epoch 8/20\n",
            "500/500 [==============================] - 13s 27ms/step - loss: 0.2494 - val_loss: 0.3221\n",
            "Epoch 9/20\n",
            "500/500 [==============================] - 12s 23ms/step - loss: 0.2434 - val_loss: 0.3414\n",
            "Epoch 10/20\n",
            "500/500 [==============================] - 13s 26ms/step - loss: 0.2366 - val_loss: 0.3291\n",
            "Epoch 11/20\n",
            "500/500 [==============================] - 11s 21ms/step - loss: 0.2332 - val_loss: 0.3170\n",
            "Epoch 12/20\n",
            "500/500 [==============================] - 12s 25ms/step - loss: 0.2287 - val_loss: 0.3415\n",
            "Epoch 13/20\n",
            "500/500 [==============================] - 13s 26ms/step - loss: 0.2264 - val_loss: 0.3333\n",
            "Epoch 14/20\n",
            "500/500 [==============================] - 15s 30ms/step - loss: 0.2239 - val_loss: 0.3318\n",
            "Epoch 15/20\n",
            "500/500 [==============================] - 14s 27ms/step - loss: 0.2213 - val_loss: 0.3522\n",
            "Epoch 16/20\n",
            "500/500 [==============================] - 14s 27ms/step - loss: 0.2187 - val_loss: 0.3306\n",
            "Epoch 17/20\n",
            "500/500 [==============================] - 14s 27ms/step - loss: 0.2153 - val_loss: 0.3509\n",
            "Epoch 18/20\n",
            "500/500 [==============================] - 15s 31ms/step - loss: 0.2132 - val_loss: 0.3579\n",
            "Epoch 19/20\n",
            "500/500 [==============================] - 13s 26ms/step - loss: 0.2115 - val_loss: 0.3528\n",
            "Epoch 20/20\n",
            "500/500 [==============================] - 19s 37ms/step - loss: 0.2101 - val_loss: 0.3241\n",
            "5.378063253561655\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 22.9\n",
        "#     Plot learning curve\n",
        "def plot_learning_curve():\n",
        "    val_loss = history.history['val_loss']\n",
        "    tr_loss=history.history['loss']\n",
        "    epochs = range(1, len(val_loss) +1)\n",
        "    plt.plot(epochs,val_loss, 'b', label = \"Validation MAE\")\n",
        "    plt.plot(epochs, tr_loss, 'r', label = \"Training MAE\")\n",
        "    plt.title(\"Training and validation MAE\")\n",
        "    plt.legend()\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "woAlyREnPXgp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 22.8 Plot loss history\n",
        "#      This function is defined at the end\n",
        "plot_learning_curve()"
      ],
      "metadata": {
        "id": "tJQL7-VPKUkK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "outputId": "b1f0e396-ad28-4053-c9c2-6a8a0f533860"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEICAYAAABPgw/pAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXgUVbr48e9LCAkQ9gQTCQjOAA4ubAFG3IKKA4ogigujI8h1vTJu4zg6i3LxekdHr9vv4r6NDoLoKIMYxRVxnSEiOiKgiFHCGsMqIZCE9/fHqU46TXfSSbrT6e738zz1dHXV6aq3O523Tp86p0pUFWOMMfGvVawDMMYYExmW0I0xJkFYQjfGmARhCd0YYxKEJXRjjEkQltCNMSZBWEI3BxCRV0VkSqTLxpKIFInIyVHYrorIT735h0TkT+GUbcR+zheR1xsbp0kOltAThIj86DftF5E9fs/Pb8i2VHWsqv410mUTnaperqq3NnU7ItLbS/6t/bY9W1VPaeq2g+wr39vXSwHLB3rLFwcsFxFZKyJfBtnWYhEpD/guvhzpmE1oresvYuKBqmb45kWkCLhYVd8MLCcirVW1sjljMy1eCXC0iHRT1VJv2RTgqyBljwe6A61FZJiqLg1YP11VH4tirKYOVkNPcF4NrFhEficim4AnRaSLiCwUkRIR2ebN5/q9ZrGIXOzNTxWR90XkLq/styIytpFl+4jIEhHZJSJvisgsEflbiLjDifFWEfnA297rIpLpt/5XIvKdiJSKyB/q+HxGiMgmEUnxWzZRRD735oeLyEcisl1ENorI/4lImxDbekpE/tvv+W+912wQkWkBZU8TkU9FZKeIrBORGX6rl3iP271a7tG+z9bv9SNFZKmI7PAeR4b72QSxD5gPnOe9PgU4F5gdpOwU4B9AgTdvWhBL6MkhG+gKHAJcivu7P+k97wXsAf6vjtePAFYDmcBfgMdFRBpR9lngX0A3YAbwqzr2GU6MvwQuwtUY2wDXA4jIAOBBb/sHe/vLJQhV/SewGzgxYLvPevNVwLXe+zkaOAn4zzrixothjBfPaKAvENh+vxu4EOgMnAZcISJneOuO9x47q2qGqn4UsO2uwCvA/d57uxt4RUS6BbyHAz6bOjztxQPwC+ALYEPAftsBk3CJfjZwXqiDm4kNS+jJYT9wi6ruVdU9qlqqqn9X1TJV3QXcBpxQx+u/U9VHVbUK+CuQAxzUkLIi0gsYBtysqvtU9X1gQagdhhnjk6r6laruAeYBg7zlk4CFqrpEVfcCf/I+g1DmAJMBRKQDcKq3DFX9RFU/VtVKVS0CHg4SRzDnePF9oaq7cQcw//e3WFX/rar7VfVzb3/hbBfcAeBrVX3Gi2sOsAo43a9MqM8mKFX9EOgqIv1xif3pIMXOBPYCr+MOKKleLP7u937N+KYmn1Mw4bOEnhxKVLXc90RE2onIw16TxE7cT/zO/s0OATb5ZlS1zJvNaGDZg4GtfssA1oUKOMwYN/nNl/nFdLD/tr2EWkpozwJnikgaLmktU9XvvDj6ec09m7w4/gdXW69PrRiA7wLe3wgRecdrUtoBXB7mdn3b/i5g2XdAD7/noT6bujwDTAdGAS8FWT8FmOcdRMqBv3Ngs8tVqtrZbwrZ68dEniX05BB4Sc3fAP2BEarakZqf+KGaUSJhI64G2M5vWc86yjclxo3+2/b22S1UYVX9EpcQx1K7uQVc080qoK8Xx+8bEwOu2cjfs7hfKD1VtRPwkN9267sE6gZcU5S/XsD6MOKqyzO45qSCgAMv3vmLE4ELvIPbJtwvoVPraZ83zcgSenLqgGuT3u61x94S7R16Nd5CYIaItBGRo6ndRBDJGF8AxonIsV4b70zq/64/C1yNO3A8HxDHTuBHETkMuCLMGOYBU0VkgHdACYy/A+4XS7mIDMcdSHxKcE1Eh4bYdgHQT0R+KSKtReRcYACwMMzYglLVb3HNPsFOIv8K1+ulP675ZhDQDyjGa64ysWcJPTndC7QFfgA+Bl5rpv2ejzuxWAr8N/Acrk02mEbHqKorgCtxSXojsA2XeOria8N+W1V/8Ft+PS7Z7gIe9WIOJ4ZXvffwNrDGe/T3n8BMEdkF3Iw7APheW4Y7Z/CB1w7984BtlwLjcL9iSoEbgHEBcTeKqr6vqhuCrJoCPKCqm/wn3C8L/2aX/5Pa/dA/aWpMJnxiN7gwsSIizwGrVDXqvxCMSQZWQzfNRkSGichPRKSV161vAq7/szEmAmykqGlO2cCLuBOUxcAVqvppbEMyJnFYk4sxxiQIa3IxxpgEEbMml8zMTO3du3esdm+MMXHpk08++UFVs4Kti1lC7927N4WFhbHavTHGxCURCRwlXM2aXIwxJkFYQjfGmARhCd0YYxKE9UM3JsFVVFRQXFxMeXl5/YVNi5Genk5ubi6pqalhv8YSujEJrri4mA4dOtC7d29C35fEtCSqSmlpKcXFxfTp0yfs11mTizEJrry8nG7dulkyjyMiQrdu3Rr8q6rehC4iT4jIFhH5IsR6EZH7RWSNiHwuIkMaFIExJuosmcefxvzNwqmhPwWMqWP9WNw9E/vi7lf5YIOjaIgPPoCbbgK7ZIExxtRSb0JX1SXA1jqKTACeVudj3G3CciIV4AGWLoXbb4dt26K2C2NM5IwaNYpFixbVWnbvvfdyxRWh7xWSn59fPfDw1FNPZfv27QeUmTFjBnfddVed+54/fz5ffvll9fObb76ZN998syHhB7V48WJEhMcee6x62fLlyxGRWjFVVlaSlZXFjTfeWOv1+fn59O/fn0GDBjFo0CAmTZrU5JggMm3oPah978Riat/bsJqIXCoihSJSWFJS0ri95XjHio0bG/d6Y0yzmjx5MnPnzq21bO7cuUyeHN6NjgoKCujcuXOj9h2Y0GfOnMnJJ5/cqG0FOuKII5g3r/q+JMyZM4eBAwfWKvPGG2/Qr18/nn/+eQIvhDh79myWL1/O8uXLeeGFFyISU7OeFFXVR1Q1T1XzsrKCXoqgftnZ7tESujFxYdKkSbzyyivs27cPgKKiIjZs2MBxxx3HFVdcQV5eHocffji33BL8Pie9e/fmhx/czZhuu+02+vXrx7HHHsvq1auryzz66KMMGzaMgQMHctZZZ1FWVsaHH37IggUL+O1vf8ugQYP45ptvmDp1anXyfOuttxg8eDBHHnkk06ZNY+/evdX7u+WWWxgyZAhHHnkkq1atChrXIYccQnl5OZs3b0ZVee211xg7dmytMnPmzOHqq6+mV69efPTRR037IMMQiW6L66l9M9xcmn6z2tB8NfRNm+ouZ4w5wDXXwPLlkd3moEFw772h13ft2pXhw4fz6quvMmHCBObOncs555yDiHDbbbfRtWtXqqqqOOmkk/j888856qijgm7nk08+Ye7cuSxfvpzKykqGDBnC0KFDATjzzDO55JJLAPjjH//I448/zq9//WvGjx/PuHHjDmjSKC8vZ+rUqbz11lv069ePCy+8kAcffJBrrrkGgMzMTJYtW8YDDzzAXXfdVatpxd+kSZN4/vnnGTx4MEOGDCEtLa3WPt58800efvhhtm/fzpw5cxg5cmT1+vPPP5+2bdsCMHr0aO688856Pun6RaKGvgC40Ovt8nNgh6pGr/psTS7GxB3/Zhf/5pZ58+YxZMgQBg8ezIoVK2o1jwR67733mDhxIu3ataNjx46MHz++et0XX3zBcccdx5FHHsns2bNZsWJFnfGsXr2aPn360K9fPwCmTJnCkiVLqtefeeaZAAwdOpSioqKQ2znnnHN4/vnnmTNnzgFNSAsXLmTUqFG0bduWs846i/nz51NVVVW93r/JJRLJHMKooYvIHCAfyBSRYtzdy1MBVPUh3B3IT8XdCLcMuCgikYWSkQHt2lkN3ZhGqKsmHU0TJkzg2muvZdmyZZSVlTF06FC+/fZb7rrrLpYuXUqXLl2YOnVqo0ezTp06lfnz5zNw4ECeeuopFi9e3KR4fTXtlJQUKisrQ5bLzs4mNTWVN954g/vuu48PP/ywet2cOXN4//338V0mvLS0lLfffpvRo0c3Kba6hNPLZbKq5qhqqqrmqurjqvqQl8zxerdcqao/UdUjVTW618QVcbV0q6EbEzcyMjIYNWoU06ZNq67J7ty5k/bt29OpUyc2b97Mq6++Wuc2jj/+eObPn8+ePXvYtWsXL7/8cvW6Xbt2kZOTQ0VFBbNnz65e3qFDB3bt2nXAtvr3709RURFr1qwB4JlnnuGEE05o1HubOXMmd9xxBykpKdXLdu7cyXvvvcf3339PUVERRUVFzJo1izlz5jRqH+GKz6H/ltCNiTuTJ09m4sSJ1U0vAwcOZPDgwRx22GH07NmTY445ps7XDxkyhHPPPZeBAwfSvXt3hg0bVr3u1ltvZcSIEWRlZTFixIjqJH7eeedxySWXcP/999fqSZKens6TTz7J2WefTWVlJcOGDePyyy9v1Pvybxf3eemllzjxxBNrtalPmDCBG264ofrkq38bemZmZkS6U8bsnqJ5eXna6BtcnH02fPEFrFwZ2aCMSUArV67kZz/7WazDMI0Q7G8nIp+oal6w8vF5LReroRtjzAHiM6FnZ8OOHbBnT6wjMcaYFiM+E7r1RTfGmAPEd0K3ZhdjjKkWnwndhv8bY8wB4jOhW5OLMcYcID4TemYmpKRYDd2YOFBaWlp9mdjs7Gx69OhR/dx3wa5QCgsLueqqq+rdR7C+4I3RUi+LG674HFiUkgLdu1sN3Zg40K1bN5Z7VwSbMWMGGRkZXH/99dXrKysrad06eCrKy8sjLy9ol+ta/IfcN5XvsrgXX3wxUP9lcf/85z/XurvQ7Nmzw4o5GuKzhg7WF92YODZ16lQuv/xyRowYwQ033MC//vUvjj76aAYPHszIkSOrL427ePFixo0bB7iDwbRp08jPz+fQQw/l/vvvr95eRkZGdfn8/HwmTZrEYYcdxvnnn199HfKCggIOO+wwhg4dylVXXVW93UAt8bK44YrPGjq4hL5hQ6yjMCa+xOL6uSEUFxfz4YcfkpKSUn3tk9atW/Pmm2/y+9//nr///e8HvGbVqlW888477Nq1i/79+3PFFVeQmppaq8ynn37KihUrOPjggznmmGP44IMPyMvL47LLLmPJkiX06dOn3ptrtLTL4oYrfhN6djYsWxbrKIwxjXT22WdXX9Bqx44dTJkyha+//hoRoaKiIuhrTjvtNNLS0khLS6N79+5s3ryZ3NzcWmWGDx9evWzQoEEUFRWRkZHBoYceSp8+fQB3XZlHHnkkZGznnHMO5557LqtWrWLy5Mm1mnQCL4t76623cu+991a/l1g2ucRvQs/Jgc2boarKtakbY+oXq+vnBtG+ffvq+T/96U+MGjWKl156iaKiIvLz84O+xr+mHOrStuGUqU9LuyxuuOI3oWdnw/79UFJS0y/dGBOXduzYQY8e7lbETz31VMS3379/f9auXUtRURG9e/fmueeeq/c1M2fOZMuWLUEvi7tu3brqA8eTTz7JnDlzWkRCj++TomA9XYxJADfccAM33XQTgwcPblSNuj5t27blgQceYMyYMQwdOpQOHTrQqVOnOl8zcuRIzjjjjFrLQl0W9+WXX651WVxft8VI3ZA6XGFdPldExgD3ASnAY6p6e8D6Q4AngCxgK3CBqhbXtc0mXT4X4KOPYORIKCiAgDPQxpgadvlc58cffyQjIwNV5corr6Rv375ce+21sQ6rThG/fK6IpACzgLHAAGCyiAwIKHYX8LSqHgXMBP7ciNgbxob/G2Ma4NFHH2XQoEEcfvjh7Nixg8suuyzWIUVcOG3ow4E1qroWQETmAhMA/7u5DgCu8+bfAeZHMsigrMnFGNMA1157bYuvkTdVOG3oPYB1fs+LvWX+PgPO9OYnAh1EpFvghkTkUhEpFJHCkpKSxsRbIz0dOne2GroxYYjVnclM4zXmbxapk6LXAyeIyKfACcB6oCqwkKo+oqp5qpqXlZXV9L1mZ1tCN6Ye6enplJaWWlKPI6pKaWkp6enpDXpdOE0u64Gefs9zvWX+O9+AV0MXkQzgLFXd3qBIGiMnx5pcjKlHbm4uxcXFNPlXsWlW6enpBwyaqk84CX0p0FdE+uAS+XnAL/0LiEgmsFVV9wM34Xq8RF9ODnz8cbPsyph4lZqaWj1C0iS2eptcVLUSmA4sAlYC81R1hYjMFJHxXrF8YLWIfAUcBNwWpXhry852NXT7KWmMMeGNFFXVAqAgYNnNfvMvAC9ENrQw5ORAWRns2gUdOzb77o0xpiWJ35GiYPcWNcYYP/Gd0H2Di+zEqDHGxHlCtxq6McZUi++EbsP/jTGmWnwn9C5dIC3NmlyMMYZ4T+giNlrUGGM88Z3QwRK6McZ44j+h2/B/Y4wBEiWhWw3dGGMSIKFnZ0NpKezbF+tIjDEmpuI/ofv6om/eHNs4jDEmxhInoVuzizEmycV/Qrfh/8YYAyRCQrcaujHGAImQ0Lt3dwOMLKEbY5Jc/Cf01FTIzLQmF2NM0gsroYvIGBFZLSJrROTGIOt7icg7IvKpiHwuIqdGPtQ6WF90Y4ypP6GLSAowCxgLDAAmi8iAgGJ/xN2abjDunqMPRDrQOtnwf2OMCauGPhxYo6prVXUfMBeYEFBGAd894DoBGyIXYhhs+L8xxoSV0HsA6/yeF3vL/M0ALhCRYty9R38dbEMicqmIFIpIYUlJSSPCDcGX0O1m0caYJBapk6KTgadUNRc4FXhGRA7Ytqo+oqp5qpqXlZUVoV3jmlwqKmDr1sht0xhj4kw4CX090NPvea63zN9/APMAVPUjIB3IjESAYbG+6MYYE1ZCXwr0FZE+ItIGd9JzQUCZ74GTAETkZ7iEHsE2lXpYQjfGmPoTuqpWAtOBRcBKXG+WFSIyU0TGe8V+A1wiIp8Bc4Cpqs3YoG3D/40xhtbhFFLVAtzJTv9lN/vNfwkcE9nQGsBq6MYYkwAjRQEyMqB9e0voxpiklhgJHawvujEm6SVWQrcaujEmiSVOQrfh/8aYJJc4Cd2aXIwxSS6xEvrOnVBWFutIjDEmJhInoVtfdGNMkkuchG590Y0xSc4SujHGJIjESejW5GKMSXKJk9AzMyElxWroxpiklTgJvVUrOOggS+jGmKSVOAkdrC+6MSapJV5Ctxq6MSZJJVZCt+H/xpgkllgJPScHSkqgqirWkRhjTLMLK6GLyBgRWS0ia0TkxiDr7xGR5d70lYhsj3yoYcjJgf37YcuWmOzeGGNiqd47FolICjALGA0UA0tFZIF3lyIAVPVav/K/BgZHIdb6+fdF9w00MsaYJBFODX04sEZV16rqPmAuMKGO8pNx9xVtfjZa1BiTxMJJ6D2AdX7Pi71lBxCRQ4A+wNsh1l8qIoUiUlhSUtLQWOtnCd0Yk8QifVL0POAFVQ16VlJVH1HVPFXNy8rKivCucQOLwPqiG2OSUjgJfT3Q0+95rrcsmPOIVXMLQHo6dOliNXRjTFIKJ6EvBfqKSB8RaYNL2gsCC4nIYUAX4KPIhthANrjIGJOk6k3oqloJTAcWASuBeaq6QkRmish4v6LnAXNVVaMTapiys63JxRiTlOrttgigqgVAQcCymwOez4hcWE2QkwMffhjrKIwxptkl1khRqBn+H+MfCsYY09wSL6Hn5EB5ubthtDHGJJHETOhgJ0aNMUkn8RK6b/i/JXRjTJJJvITuq6FbTxdjTJJJ3IRuNXRjTJJJvITeqROkpVkN3RiTdBIvoYvYaFFjTFJKvIQOltCNMUkpMRO6Df83xiShxEzoVkM3xiShxEzo2dmwdSvs3RvrSIwxptkkZkL3dV3cvDm2cRhjTDNK7IRuzS7GmCSSmAndhv8bY5JQYiZ0G/5vjElCYSV0ERkjIqtFZI2I3BiizDki8qWIrBCRZyMbZgN17+4GGFkN3RiTROq9Y5GIpACzgNFAMbBURBao6pd+ZfoCNwHHqOo2EekerYDD0ro1ZGVZDd0Yk1TCqaEPB9ao6lpV3QfMBSYElLkEmKWq2wBUdUtkw2wE64tujEky4ST0HsA6v+fF3jJ//YB+IvKBiHwsImOCbUhELhWRQhEpLCkpaVzE4bKEboxJMpE6Kdoa6AvkA5OBR0Wkc2AhVX1EVfNUNS8rKytCuw7Bhv8bY5JMOAl9PdDT73mut8xfMbBAVStU9VvgK1yCj52cHJfQ9++PaRjGGNNcwknoS4G+ItJHRNoA5wELAsrMx9XOEZFMXBPM2gjG2XDZ2VBZCaWlMQ3DGGOaS70JXVUrgenAImAlME9VV4jITBEZ7xVbBJSKyJfAO8BvVTW2mdT6ohtjkky93RYBVLUAKAhYdrPfvALXeVPL4D/8/8gjYxuLMcY0g8QcKQo2/N8Yk3QSN6Fbk4sxJskkbkJv3x46dLAaujEmaSRuQgfri26MSSqJndBttKgxJolYQjfGmASR2AndmlyMMUkksRN6Tg7s2gW7d8c6EmOMibrETujWF90Yk0QSO6FbX3RjTBJJjoRuNXRjTBJI7IRuTS7GmCSS2Am9Wzd3f1FrcjHGJIHETuitWrlautXQjTFJILETOlhfdGNM0kj8hG6jRY0xSSKshC4iY0RktYisEZEbg6yfKiIlIrLcmy6OfKiNZAndGJMk6r1jkYikALOA0bibQS8VkQWq+mVA0edUdXoUYmya7GwoKXH3F20d1g2ajDEmLoVTQx8OrFHVtaq6D5gLTIhuWBGUkwOqsGVLrCMxxpioCieh9wDW+T0v9pYFOktEPheRF0SkZ7ANicilIlIoIoUlJSWNCLcRrC+6MSZJROqk6MtAb1U9CngD+GuwQqr6iKrmqWpeVlZWhHZdDxv+b4xJEuEk9PWAf40711tWTVVLVXWv9/QxYGhkwosAG/5vjEkS4ST0pUBfEekjIm2A84AF/gVEJMfv6XhgZeRCbKKDDnKPltCNMQmu3m4fqlopItOBRUAK8ISqrhCRmUChqi4ArhKR8UAlsBWYGsWYGyYtDbp2tSYXY0zCC6sfn6oWAAUBy272m78JuCmyoUWQ9UU3xiSBxB8pCjb83xiTFJIjoVsN3RiTBJIroavGOhJjjIma5Ejo2dmwdy/s2BHrSIwxJmqSI6FbX3RjTBKwhG6MMQkiORK673ou1tPFGJPAkiOhWw3dGJMEkiOhd+wI6emW0I0xCS05ErqIq6Vbk4sxJoElR0IHG1xkjEl4yZPQs7MtoRtjElryJHRrcjHGJLjkSujbtkF5eawjMcaYqEiehO7ri755c2zjMMaYKEmehG590Y0xCS6shC4iY0RktYisEZEb6yh3loioiORFLsQIsYRujElw9SZ0EUkBZgFjgQHAZBEZEKRcB+Bq4J+RDjIibPi/MSbBhVNDHw6sUdW1qroPmAtMCFLuVuAOoGWedezeHVq1shq6MSZhhZPQewDr/J4Xe8uqicgQoKeqvlLXhkTkUhEpFJHCkpKSBgfbJCkpkJXVpIS+dy/cdhuceCKsXRvB2IwxJgKafFJURFoBdwO/qa+sqj6iqnmqmpeVldXUXTdcE/qiv/oqHHEE/PGP8NFHcOyxsGJFhOMzxpgmCCehrwd6+j3P9Zb5dACOABaLSBHwc2BBiz0x2sAaelERnHEGnHqqa7FZtAiWLnXrTjgBCgsjH6YxxjRGOAl9KdBXRPqISBvgPGCBb6Wq7lDVTFXtraq9gY+B8ara8lJdA4b/l5fDzJnws5/Bm2/C7bfDv/8Np5ziaurvvQcdOrjmlyVLohy3McaEod6ErqqVwHRgEbASmKeqK0RkpoiMj3aAEZWT4wYW7d9fZ7GFC+Hww+GWW2D8eFi1Cn73O2jTpqbMT34C778Pubnwi19AQUGUYzfGmHqE1YauqgWq2k9Vf6Kqt3nLblbVBUHK5rfI2jm4hF5VBT/8EHT12rVw+uluSktzNfPnnnNJO5gePeDdd2HAAJgwAebNi2LsxhhTj+QZKQoh+6Lv2eNq4wMGwOLFcOedsHw5nHRS/ZvMyoK334af/xwmT4bHH4982MYYE47kSugBo0VV4R//cIl85kw480zXvHL99bWbV+rTqZM7WXrKKXDxxXDPPVGI3Rhj6pG0CX3NGjjtNNeDpX17eOcdePZZ14zSGO3auYPDpElw3XUwY4Y7YBhjTHNpHesAmpXX5PL605s4/TLXTn733TB9OqSmNn3zbdrAnDmu98t//Rfs2OG2L9L0bRtjGkYVdu6E9euhuLhm2rQJMjIgM9M1mWZm1p46d47f/9mET+jl5a43yuuvw+uvt+NdOrLynY2ccwH85S81lfZIad0aHnvMJfV773VfqEcecQNVjYl3qvD9966jQCy/06qub0Ngsi4urr3sxx8PfG3XrrB7txv5HUxKSu0EH5j0u3d3Pdu6do3ue2yMhEvoqq6/+BtvuCS+ZIlL6m3awDHHQGVmNlOGbOTqZ6IXQ6tWLpl36gS33gq7dsHf/tawdnljWorKSjfu4qWXYP58WLfO/didNAnOOcf9X7WKcuNtVZWrmM2f70ZtFxUdmJBbtYKDD3YHm8MPd0k3N7dm6tHDrU9Lc3mirAxKStyBwTcFe75ihZsvLa3p8dyuHUydCtdcA337Rve9N4RojBp68/LytDBCwyw3bXJdDF9/3SVyXyeWAQPcicpTToHjj3dt5eTnu79KM40G+t//dSdZx46FF15wX4SGKitzB6nPPnPTpk1ulOppp7n+8MZE2p497n/ppZfg5ZddMktPd/9L+fkuuRYUuMpSTk5Nch85MnLJvbzcxTB/PixY4JJqWprrfXb44bUTdW4uHHSQ+4UcLfv3w/bt8M038NBDrpJWUeHGqlx3HRx3XPM01YjIJ6oadCR+XCb0PXv8m1Hg88/d8sxMGD3afelGjw5xgnPyZDde/+uvGx98Az36KFx2mbv+y8KF0LFj8HKqsGFDTeJevtw9fv11Tc2gY0f3U6+oyD0/7DCX2E87zW0/EucCWqqKCldTLCyEn/4UBg+G3r3jp71TFT791NUwMzNd7H36QK9eLlnG2vbt8MorLom/9pprlujUCcaNg4kTXY03I6Om/K5drvy8eS65793rasC+5H700USAD6kAABEmSURBVA1P7r4YfDXx3bvdd37cONeBYcwY15zZEmzaBA884KbSUhg61CX2s8+O7v9hXQkdVY3JNHToUG2M++9XTU9XBdU2bVRPPFH19ttVly1TraoKYwPXXKPavn2j9t0Uc+aotm6tOnSoakmJ6t69qp99pvrXv6ped53qSSepZma69+Wb+vRRPeMM1VtuUX3xRdW1a1X373fbW7NG9b77VEePdp8DqHbsqHr22apPPaW6eXOzv8WoKC1V/dvfVM89V7VTp9qfD6h27qw6apT7DJ95RnXFCtXKylhHXduWLar33KN61FEHxu+bDj5YdeRI1fPPV/3DH1Qfe0z1rbdUv/lGdd++6MW2YYPqgw+qnnKK+36Cana26uWXqy5a5L6n4di5U/XZZ933NS3NbadHD/fv9sEHdf9vrl+v+sADwWN47bXwY4iVsjLVhx9WPeywmvd9xx2qW7dGZ39AoYbIq3FXQ1+82P38OuUU9xOnffsGbuDuu+E3v4E77nCH02j+Rgvwyiuu9tK2rTtZU1Hhlqenu+vDDBwIgwa5x6OOcrWjcPz4o2tyWrjQ1ZQ2bnS11uHDa2rvgwfHT0129Wr3M//ll+GDD1z76UEHufdx+unul8jata62++mnsGyZa5Ly3f+7bVv3+Q0eDEOGuMcjjmjeWnBlpRub8MQT7n1UVEBeHkyb5mqve/bAt9+6X1qBj+vWuffs06qVa1Lo08fV6nv1ct/7Nm2CT6mpode1aeM+p1dfdTXxjz92h5Sf/tTVwidOhBEjmtZssnOn+y7Om+f2s2+fi//ss900YgSsWeNq4b4YwLVFT5zoauJNjSEW9u93v2zuvhveesv9jaZNg6uvjmzTaMI1uTTJ9u3ubMY//uH+0x991P1WaiZLlsCsWe6f05fA+/aN3HFl/37XVPPKK+6faulS9w978MHuipGnnQajRrl/lvJy9zO5vLz2fH2P+/e7dtOePd2Um9u4cwM+lZWuCc2XxH2tYUcdVXMphmHD6v4Hr6x0g8J8Cd6X7HfudOtbt3YXWvMleN+Bs3PnxscdzKpV8OST8Mwz7sCalQW/+hVcdJE7qISjosL11PBP9P7zGzZEZozD4ME1Sfzww6NzwN+50/1N581zyW7fPldR2bHDrR86tCaJDxgQP5WO+nz2mRtg+Oyz7rt5xhmuHjlyZNPfoyX0QKrw4ouuA/qWLe5U9cyZjajut3xbtrha0sKF7nyDL8FFWteuNQneP9H7z6el1ZTfts39g7/8sotv+3ZXexw1yiXwcePgkEOaFtP+/S4B+pK7L9lv3lxTpndvl9z9p169GvZPt3OnS1hPPOGulZ+S4g6cF13kDqKR7t1UVeUSY2Omigr39T/uOPfem9OOHe7v/dZb7mByxhnus05kGze6CtyDD8LWre5X83XXwVlnNb4SZwk9lO3b4cYb4eGH3bf7oYfcmZ8EVVHhasL/+pf7MqWluWaIwMdgy/zXgaslrltXeyourpnfuvXA/Xfv7hJ7ejr8858uMWVl1TSljB7dPCe8Nm6sOensm776qqbW27lzTQ3el+QHDKidmH0dpZ580vVeKitzvwCmTYMLLqi5bJAx4E7uPv20q7V//bVr8b3hhsZtyxJ6fd57Dy691P1e/uUvXSfyWNxRKYHs3l0zuCMw8e/c6bpdnn66q7G0hEFXu3e7dnhfgv/sM9d7qqzMrU9NdUl90CB3YHrhBVf779jRdZy66CL3XhKlycBEx/79rjl0xAj3PWoMS+jh2LsX/ud/4M9/dtXEu++GCy+0/9AkVlXlTt751+SXL3fd1U46ySXxiRObdv7AmIZqckIXkTHAfUAK8Jiq3h6w/nLgSqAK+BG4VFW/rGubLS6h+3z5JVxyCXz4ofuvffhhG71jaikvbxn9xk1yqiuh19sxSERSgFnAWGAAMFlEBgQUe1ZVj1TVQcBfcDeNjk8DBrgmmAcecF1EjjjCNXj5+hiapGfJ3LRU4fT0HA6sUdW1qroPmAtM8C+gqv59J9oD8X3h2Fat4IorXG197Fh34nTYMLsjtDGmRQsnofcA1vk9L/aW1SIiV4rIN7ga+lWRCS/GevRw3RtffNH1/xsxwvU5CnYJN2OMibGIjcVS1Vmq+hPgd8Afg5URkUtFpFBECktKSiK16+ibOBFWrnQXZLnnHjcSaOpUeOop19XB7mRhjGkBwkno64Gefs9zvWWhzAXOCLZCVR9R1TxVzcuKt26BnTq5dvX333fDvRYudN0cDj3U9WG/8EJ3Q9FvvrEEb4yJiXDGKi0F+opIH1wiPw/4pX8BEemrqr7LF54GNN+lDJvbMce4af9+18b+7rvuAjOvvebGe4NrqsnPd52tTzjB1eit+6MxJsrqTeiqWiki04FFuG6LT6jqChGZibvq1wJguoicDFQA24Ap0Qy6RWjVyvWAOeIIuPJKVytftcol93ffdVfLmj3blc3JqUnu+fnQv78leGNMxNnAomhRdePJfQl+8WI35hzcELG8vJpp6FB39SxjjKmHjRRtCVTdsMN333Xt8IWF7kSr784VOTm1E3xenrtmrDHG+KkroSfcPUVbLBHXlt63L1x8sVu2e7cbS15Y6KZPPnEnW30H2dzc2gl+6FC7xowxJiRL6LHUvn3NSVafXbvcdV59Cb6w0N0JwKdXL3ftUd+9yw45xD326uWSvbXNG5O0LKG3NB06uDtaH398zbIdO2qSfGGhuwzgG2/UXArQJz29JrkHJvtDDjnwouTGmIRiCT0edOrkesfk59csU3UXHf/+e/juO/foP19Q4C4LGCg7291xols3d1cK3xT43Dd17tyst+kzxjSe/afGKxGXhLt1c00wwezd6y5AHpjsi4vhhx9cL5ytW92NPurSqdOBib5LF5fsu3QJPnXu7F4XbzeGNCaOWUJPZGlp7u6/P/1p3eWqqlxS37o1vOm779w95LZtczdMDEXEJfXARN+1q+vBk51d8+ibz8iw8wDGNJIldONuGeSr7TeEquup40vu27a5A4P/88B1GzZAaan7heDrsumvXbvQyd7/MSfHrmNrTABL6KbxRFyNOiPDtcs3RFWVS+qbNrm7Nm/aVHt+82Z388X33nMHgGC6dXOXWahr6tbNavwmaVhCN7GRkuJq2+EMnqqocJcv9iX6jRtdTX/9+prpk09cmUBpaW4Uri/BH3ywmzp3djcE9U0dOtSetxPBJg7Zt9a0fKmpNQm5Lvv2BU/2/kl/wQLYs6f+fbZrFzrhd+zozgf4nyAOPGFs3UNNDFhCN4mjTRvX3/6QQ0KXUYWdO2umXbtqP69r3bffuscdO9z5gLoum9Gu3YHJ3jffpYtb37Ztwyb71WDqYd8Qk1x8PW86dWradvbvd8nd1/Nn27baPYH8n2/b5s4H+J6Xlzdun61b1xwI2rULPtW1LnBq377m0Tfftq2dc4hjltCNaYxWrVw7fOfO7iYnDVFe7pp9GjuVldWeLytzJ47Xrat5XlbmeiBVVTX8vQUm+WCJ3/dY38Ei2JSWZgeNKLGEbkxzS093U5cu0d9XRUXtJB+Y8Hfvrpmvb9mWLTXz/geThl6xtVUrd04i8ER0XecsAsu2a1fzOaal2QA2jyV0YxJZampkmphCUXW/OOo6aARb5js/4X+eYv362ssacqBIS6tJ8OnprunI/3ngsrS02lObNgcuq2t9mzZuSk0N/piSEp3Pux5hJXQRGQPch7tj0WOqenvA+uuAi4FKoASYpqrfRThWY0xLI1Jz0rahA9Pq4hu0FuoEta/Zqry89hS4zPe8tLT28717a0+RJlI7wQcm/Rkz4NxzI77behO6iKQAs4DRQDGwVEQWqOqXfsU+BfJUtUxErgD+AkQ+WmNMcvAftBbtu3mpuqapffsOTPT+k//6fftqXhPqsa51XbtG5a2EU0MfDqxR1bUAIjIXmABUJ3RVfcev/MfABZEM0hhjosZXm27Txh1A4lg4ZxJ6AOv8nhd7y0L5D+DVYCtE5FIRKRSRwpKSkvCjNMYYU6+InhoWkQuAPODOYOtV9RFVzVPVvCy7lZoxxkRUOE0u6wH/Ky/lestqEZGTgT8AJ6hqFM4yGGOMqUs4NfSlQF8R6SMibYDzgAX+BURkMPAwMF5Vg1whyRhjTLTVm9BVtRKYDiwCVgLzVHWFiMwUkfFesTuBDOB5EVkuIgtCbM4YY0yUhNUPXVULgIKAZTf7zZ8c4biMMcY0kI2XNcaYBGEJ3RhjEoRoQy+sE6kdi5QALfXyAJnAD7EOog4WX9O09Pig5cdo8TVNU+I7RFWD9vuOWUJvyUSkUFXzYh1HKBZf07T0+KDlx2jxNU204rMmF2OMSRCW0I0xJkFYQg/ukVgHUA+Lr2laenzQ8mO0+JomKvFZG7oxxiQIq6EbY0yCsIRujDEJImkTuoj0FJF3RORLEVkhIlcHKZMvIju869MsF5Gbg20rijEWici/vX0XBlkvInK/iKwRkc9FZEgzxtbf73NZLiI7ReSagDLN/vmJyBMiskVEvvBb1lVE3hCRr73HoHdnFpEpXpmvRWRKM8V2p4is8v5+L4lI5xCvrfO7EOUYZ4jIer+/46khXjtGRFZ738cbmzG+5/xiKxKR5SFeG9XPMFROadbvn6om5QTkAEO8+Q7AV8CAgDL5wMIYxlgEZNax/lTczUQE+DnwzxjFmQJswg14iOnnBxwPDAG+8Fv2F+BGb/5G4I4gr+sKrPUeu3jzXZohtlOA1t78HcFiC+e7EOUYZwDXh/Ed+AY4FGgDfBb4/xSt+ALW/y9wcyw+w1A5pTm/f0lbQ1fVjaq6zJvfhbuSZF13YmqJJgBPq/Mx0FlEcmIQx0nAN9oCbgyuqkuArQGLJwB/9eb/CpwR5KW/AN5Q1a2qug14AxgT7dhU9XV1VzQFd/vG3Ejus6FCfH7hqL5VparuA3y3qoyouuITEQHOAeZEer/hqCOnNNv3L2kTuj8R6Q0MBv4ZZPXRIvKZiLwqIoc3a2CgwOsi8omIXBpkfUNvDxgt5xH6nyiWn5/PQaq60ZvfBBwUpExL+CynEeL2jdT/XYi26V6z0BMhmgxawud3HLBZVb8Osb7ZPsOAnNJs37+kT+gikgH8HbhGVXcGrF6Ga0YYCPw/YH4zh3esqg4BxgJXisjxzbz/eom76cl44Pkgq2P9+R1A3e/bFtdXV0T+AFQCs0MUieV34UHgJ8AgYCOuWaMlmkzdtfNm+QzryinR/v4ldUIXkVTcBz9bVV8MXK+qO1X1R2++AEgVkczmik9V13uPW4CXcD9r/YV1e8AoGwssU9XNgSti/fn52exrivIeg91VK2afpYhMBcYB53v/8AcI47sQNaq6WVWrVHU/8GiIfcf0uygirYEzgedClWmOzzBETmm271/SJnSvve1xYKWq3h2iTLZXDhEZjvu8SpspvvYi0sE3jzt59kVAsQXAhV5vl58DO/x+2jWXkLWiWH5+ARYAvl4DU4B/BCmzCDhFRLp4TQqneMuiSkTGADfgbt9YFqJMON+FaMbof15mYoh913uryig7GVilqsXBVjbHZ1hHTmm+71+0zvi29Ak4FvfT53NguTedClwOXO6VmQ6swJ2x/xgY2YzxHert9zMvhj94y/3jE2AWrnfBv4G8Zv4M2+MSdCe/ZTH9/HAHl41ABa4d8j+AbsBbwNfAm0BXr2we8Jjfa6cBa7zpomaKbQ2u7dT3HXzIK3swUFDXd6EZP79nvO/X57jklBMYo/f8VFzPjm+iFWOw+LzlT/m+d35lm/UzrCOnNNv3z4b+G2NMgkjaJhdjjEk0ltCNMSZBWEI3xpgEYQndGGMShCV0Y4xJEJbQjTEmQVhCN8aYBPH/AdVYxLk5VFnyAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### GRU Model"
      ],
      "metadata": {
        "id": "JMZ6fGRDQl0k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "###################################\n",
        "### BB. GRU model\n",
        "###################################"
      ],
      "metadata": {
        "id": "kw_UmgzqQpj9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 23.1 Design model\n",
        "del model\n",
        "model = Sequential()"
      ],
      "metadata": {
        "id": "r0f-UxcBQnXO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Input layer                             240                14\n",
        "model.add(tf.keras.Input(shape = (lookback // step, float_data.shape[-1])))"
      ],
      "metadata": {
        "id": "W6CfHm1_Q-V1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 23.2 Add a Gated Recurrent Unit layer (similar to LSTM)\n",
        "#      Input sequence has 240 values\n",
        "model.add(\n",
        "          tf.keras.layers.GRU(\n",
        "                               32\n",
        "                              )\n",
        "         )"
      ],
      "metadata": {
        "id": "DOIRMEdXRAgn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mK9pfRVKQv-b",
        "outputId": "55217fda-1a68-41ba-fb62-9037b5d6ed21"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " gru (GRU)                   (None, 32)                4608      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 4,608\n",
            "Trainable params: 4,608\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 23.3 Output layer\n",
        "model.add(layers.Dense(1))\n",
        "\n",
        "# 23.4 How does model look like?\n",
        "model.summary()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fdS1f4gubSBx",
        "outputId": "47927fb8-4d77-43e1-f320-17938efcbec5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " gru (GRU)                   (None, 32)                4608      \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 1)                 33        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 4,641\n",
            "Trainable params: 4,641\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Our model"
      ],
      "metadata": {
        "id": "AfQZD9iHaQuT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "T2vweKrHayiw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 23.5 Compile the model\n",
        "model.compile(optimizer=RMSprop(), loss='mae')"
      ],
      "metadata": {
        "id": "FKxq2m3Ka8Jy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 23.6 Train the model\n",
        "# Refer: https://stackoverflow.com/a/44277785\n",
        "# For better comparision, keep steps_per_epoch to 500\n",
        "\n",
        "start = time.time()    # Takes 10 minutes\n",
        "history = model.fit_generator(train_gen,    # Each time train_gen is called, it\n",
        "                                            #  returns a sample of shape (128,240,14)\n",
        "                                            #   So 240 GRU units, each receiving\n",
        "                                            #    input vector of 14 features (Xt)\n",
        "                                            #     Size of each timeseries: 240. Total batches: 128\n",
        "                              steps_per_epoch=50,  # Total number of times generator called\n",
        "                                                   #   & samples yielded from generator\n",
        "                                                   #     Here each step brings a batch of 128\n",
        "                              epochs=20,    # What is an epoch? An epoch finishes\n",
        "                                           #  when all the steps_per_epoch batches have\n",
        "                                           #    been seen by the model.\n",
        "                              validation_data=val_gen,\n",
        "                              validation_steps=val_steps,\n",
        "                              verbose =1)\n",
        "\n",
        "end = time.time()\n",
        "print((end-start)/60)   # 2 mins on colab"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "83BDlLMjbCrH",
        "outputId": "12f5293b-fb27-48ed-cce4-e768c62b8f59"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-59-eef637b9b8e0>:4: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n",
            "  history = model.fit_generator(train_gen,    # Each time train_gen is called, it\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "50/50 [==============================] - 32s 576ms/step - loss: 0.3481 - val_loss: 0.3121\n",
            "Epoch 2/20\n",
            "50/50 [==============================] - 24s 494ms/step - loss: 0.3255 - val_loss: 0.2861\n",
            "Epoch 3/20\n",
            "50/50 [==============================] - 28s 572ms/step - loss: 0.3174 - val_loss: 0.3049\n",
            "Epoch 4/20\n",
            "50/50 [==============================] - 28s 567ms/step - loss: 0.3167 - val_loss: 0.2946\n",
            "Epoch 5/20\n",
            "50/50 [==============================] - 33s 676ms/step - loss: 0.3143 - val_loss: 0.3035\n",
            "Epoch 6/20\n",
            "50/50 [==============================] - 27s 551ms/step - loss: 0.3086 - val_loss: 0.2911\n",
            "Epoch 7/20\n",
            "50/50 [==============================] - 31s 630ms/step - loss: 0.3113 - val_loss: 0.2957\n",
            "Epoch 8/20\n",
            "50/50 [==============================] - 29s 583ms/step - loss: 0.3078 - val_loss: 0.2850\n",
            "Epoch 9/20\n",
            "50/50 [==============================] - 32s 642ms/step - loss: 0.3095 - val_loss: 0.2848\n",
            "Epoch 10/20\n",
            "50/50 [==============================] - 33s 671ms/step - loss: 0.3040 - val_loss: 0.2845\n",
            "Epoch 11/20\n",
            "50/50 [==============================] - 30s 603ms/step - loss: 0.3005 - val_loss: 0.2889\n",
            "Epoch 12/20\n",
            "50/50 [==============================] - 39s 800ms/step - loss: 0.3028 - val_loss: 0.2868\n",
            "Epoch 13/20\n",
            "50/50 [==============================] - 32s 644ms/step - loss: 0.2974 - val_loss: 0.2783\n",
            "Epoch 14/20\n",
            "50/50 [==============================] - 30s 607ms/step - loss: 0.3011 - val_loss: 0.2895\n",
            "Epoch 15/20\n",
            "50/50 [==============================] - 28s 571ms/step - loss: 0.3023 - val_loss: 0.2761\n",
            "Epoch 16/20\n",
            "50/50 [==============================] - 29s 590ms/step - loss: 0.3006 - val_loss: 0.2951\n",
            "Epoch 17/20\n",
            "50/50 [==============================] - 27s 556ms/step - loss: 0.2996 - val_loss: 0.2824\n",
            "Epoch 18/20\n",
            "50/50 [==============================] - 28s 578ms/step - loss: 0.3008 - val_loss: 0.2951\n",
            "Epoch 19/20\n",
            "50/50 [==============================] - 25s 512ms/step - loss: 0.3008 - val_loss: 0.2768\n",
            "Epoch 20/20\n",
            "50/50 [==============================] - 28s 570ms/step - loss: 0.3006 - val_loss: 0.2897\n",
            "9.914072926839193\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 23.7 Plot loss history\n",
        "#      This function is defined at the end\n",
        "plot_learning_curve()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "gpyowwCBbATH",
        "outputId": "73846c8b-7aeb-4596-e56c-7f1326a31ce1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## GRU model with dropouts"
      ],
      "metadata": {
        "id": "NONte5dJczT_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "###################################\n",
        "### CC. GRU model with dropouts\n",
        "###################################"
      ],
      "metadata": {
        "id": "YHy_yz9scyXi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Models with dropouts take longer time than without dropouts. Why? See:\n",
        "#   https://stats.stackexchange.com/a/377126\n",
        "\n",
        "\n",
        "# 24.1 Design model\n",
        "del model\n",
        "model = Sequential()\n",
        "\n",
        "# 24.2 GRU layer with dropouts\n",
        "#      What is Recurrent layer dropout?\n",
        "#      See: https://stackoverflow.com/questions/44924690/keras-the-difference-between-lstm-dropout-and-lstm-recurrent-dropout\n",
        "model.add(tf.keras.layers.GRU(32,\n",
        "                     dropout=0.2,             # Dropout of input layer\n",
        "                     recurrent_dropout=0.2,   # Dropout of recurrent layer\n",
        "                     input_shape=(None, float_data.shape[-1]) # float_data.shape[-1] = 14\n",
        "                     )\n",
        "        )"
      ],
      "metadata": {
        "id": "Nb7-36k1cvGR",
        "outputId": "617a7f23-53b3-4d92-f5ef-f4ef84a5178f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:tensorflow:Layer gru_3 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 24.3 Output layer\n",
        "model.add(tf.keras.layers.Dense(1))\n",
        "\n",
        "# 24.4 Compile te model\n",
        "model.compile(optimizer=RMSprop(), loss='mae')"
      ],
      "metadata": {
        "id": "qsebiLVtc7NA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 24.5 Model summary\n",
        "model.summary()"
      ],
      "metadata": {
        "id": "SHot8Dq8dDTk",
        "outputId": "47f47fed-374e-4f71-8a75-e9b31bfa84e7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_7\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " gru_3 (GRU)                 (None, 32)                4608      \n",
            "                                                                 \n",
            " dense_3 (Dense)             (None, 1)                 33        \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 4,641\n",
            "Trainable params: 4,641\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 24.6 Train the model\n",
        "# For better comparision, keep steps_per_epoch to 500\n",
        "\n",
        "start = time.time()     # Around 32 minutes\n",
        "history = model.fit_generator(train_gen,\n",
        "                              steps_per_epoch=500,\n",
        "                              epochs=20,\n",
        "                              validation_data=val_gen,\n",
        "                              validation_steps=val_steps,\n",
        "                              verbose =1)\n",
        "end = time.time()\n",
        "print((end-start)/60)"
      ],
      "metadata": {
        "id": "UGuR33LZc9NB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 24.7 Plot loss history\n",
        "#      This function is defined at the end\n",
        "plot_learning_curve()"
      ],
      "metadata": {
        "id": "E1aVG4XCdAcI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Stacked GRU Model"
      ],
      "metadata": {
        "id": "YuU9qlKzdjTo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "###################################\n",
        "### DD. Stacked GRU models\n",
        "###     Takes long time\n",
        "###################################"
      ],
      "metadata": {
        "id": "Ke4fNX4TdmhO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 25.1 Design model\n",
        "model = Sequential()\n",
        "# 25.2 First GRU layer\n",
        "model.add(tf.keras.layers.GRU(32,\n",
        "                     dropout=0.1,\n",
        "                     recurrent_dropout=0.5,    # Dropouts between two stacked GRU layers\n",
        "                     return_sequences=True,    # Must for stacking another layer on top\n",
        "                     input_shape=(None, float_data.shape[-1])))"
      ],
      "metadata": {
        "id": "3rrKPRNAd61I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 25.3 IInd GRU layer\n",
        "model.add(tf.keras.layers.GRU(64, activation='relu',\n",
        "                     dropout=0.1,\n",
        "                     recurrent_dropout=0.5)\n",
        "          )"
      ],
      "metadata": {
        "id": "0UD-GYCKdgX5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 25.4 Final output layer\n",
        "model.add(tf.keras.layers.Dense(1))\n",
        "# 25.6 Compile the model\n",
        "model.compile(optimizer=RMSprop(), loss='mae')"
      ],
      "metadata": {
        "id": "FYYxCP5Zd-fH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 25.5 Model summary\n",
        "model.summary()"
      ],
      "metadata": {
        "id": "zdS17Ft6eX18"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 25.7 Train the model\n",
        "# For better comparision, keep steps_per_epoch to 500\n",
        "\n",
        "start = time.time()    # Takes 82 minutes\n",
        "history = model.fit_generator(train_gen,\n",
        "                              steps_per_epoch=50,\n",
        "                              epochs=5,\n",
        "                              validation_data=val_gen,\n",
        "                              validation_steps=val_steps,\n",
        "                              verbose =1\n",
        "                              )\n",
        "end = time.time()\n",
        "print((end-start)/60)\n"
      ],
      "metadata": {
        "id": "dMlvtC7SeP4G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 25.8 Plot loss history now, epoch-wise\n",
        "#      This function is defined at the end\n",
        "plot_learning_curve()"
      ],
      "metadata": {
        "id": "Yi0cBT9IeePe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## BiDirectional RNN"
      ],
      "metadata": {
        "id": "GoqkOUnqeurC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "###################################\n",
        "### EE. Bidirectional RNN\n",
        "###     Takes long time\n",
        "###################################"
      ],
      "metadata": {
        "id": "02UiNq8oeopU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "What is bidirectional RNN?\n",
        "    Ref: Page: 220, Book on Deep Learning by Chollet\n",
        "    A bidirectional RNN is two RNNs running in parallel\n",
        "    and their outputs get concatenated to be fed to\n",
        "    classifier. One RNN considers input sequence as it\n",
        "    comes (this is a cow). The other RNN reverses the\n",
        "    sequence (cow a is this). It looks at the sequence\n",
        "    from different perspective with the hope that this\n",
        "    new angle may further assist in creating new features.\n",
        "    As Bidirectional RNN uses two RNNs they can be GRU\n",
        "    or LSTM or even SimpleRNN.\n",
        "\"\"\""
      ],
      "metadata": {
        "id": "0yAui8jAezVu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 26.1 Develop deeplearning model using bidirectioal RNN\n",
        "model = Sequential()\n",
        "model.add(layers.Bidirectional(\n",
        "                               layers.GRU(32),      # Can use LSTMs also\n",
        "                               input_shape=(None,float_data.shape[-1])\n",
        "                               )\n",
        "         )"
      ],
      "metadata": {
        "id": "BbX9yt01e20R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.add(layers.Dense(1))\n",
        "model.compile(\n",
        "              optimizer = RMSprop(),\n",
        "              loss = 'mae'\n",
        "              )"
      ],
      "metadata": {
        "id": "VEPhgqlXe5Kj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start = time.time()\n",
        "history = model.fit_generator(train_gen,\n",
        "                              steps_per_epoch = 500,\n",
        "                              epochs = 10,\n",
        "                              validation_data = val_gen,\n",
        "                              validation_steps=val_steps\n",
        "                              )\n",
        "end = time.time()\n",
        "(end-start)/60\n"
      ],
      "metadata": {
        "id": "yeBmpLS-emu-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# 26.2 Plot loss history now, epoch-wise\n",
        "#      This function is defined at the end\n",
        "plot_learning_curve()"
      ],
      "metadata": {
        "id": "nEr6JWECe7cP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "How to improve further?\n",
        "Suggestions to further improve model:\n",
        "    i)  Adjust the number of units in each recurrent layer in Stacked setup\n",
        "        Current choice is arbitrary.\n",
        "    ii) Adjust the learning rate used by RMSprop layer.\n",
        "        Syntax: RMSprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0)\n",
        "    iii)Try using LSTM layers instead of GRU layers. LSTM layers\n",
        "        are computaionally intensive but retain more memory.\n",
        "    iv) Try using a bigger densely connected regressor instead\n",
        "        of simple one as used here.\n",
        "    v)  Run the best performing model as per the history instead of\n",
        "        the model that is returned at the end of all epochs.\n",
        "    vi) Maybe add a convolution layer before recurrent layer\n",
        "\"\"\"'"
      ],
      "metadata": {
        "id": "HUoPb1a4e-V3"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}