gru128_lstm64.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/itsCheithanya/KubeCasten/blob/main/gru_lstm.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "DJYX2r2gTKc1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "02b2326a-cb94-4b13-de7d-01c47567e1fa"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "\n",
        "drive.mount('/content/gdrive')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#  /content/gdrive/My Drive/\n",
        "import pandas as pd\n",
        "\n",
        "df = pd.read_csv(r'/content/gdrive/My Drive/output1.csv')\n",
        "df.head"
      ],
      "metadata": {
        "id": "nq7XdAXdVPnf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "921f7aff-4db8-4c28-96a8-784b5a01e793"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<bound method NDFrame.head of                         IP Address                     Date/Time  \\\n",
              "0                     199.72.81.55  [01/Jul/1995:00:00:01 -0400]   \n",
              "1             unicomp6.unicomp.net  [01/Jul/1995:00:00:06 -0400]   \n",
              "2                   199.120.110.21  [01/Jul/1995:00:00:09 -0400]   \n",
              "3               burger.letters.com  [01/Jul/1995:00:00:11 -0400]   \n",
              "4                   199.120.110.21  [01/Jul/1995:00:00:11 -0400]   \n",
              "...                            ...                           ...   \n",
              "1048570  ix-atl10-28.ix.netcom.com  [14/Jul/1995:10:05:59 -0400]   \n",
              "1048571              198.133.29.18  [14/Jul/1995:10:05:59 -0400]   \n",
              "1048572              192.68.108.59  [14/Jul/1995:10:06:00 -0400]   \n",
              "1048573              192.68.108.59  [14/Jul/1995:10:06:00 -0400]   \n",
              "1048574         oregon.oxmol.co.uk  [14/Jul/1995:10:06:00 -0400]   \n",
              "\n",
              "                                                   Request  \n",
              "0                          \"GET /history/apollo/ HTTP/1.0\"  \n",
              "1                       \"GET /shuttle/countdown/ HTTP/1.0\"  \n",
              "2        \"GET /shuttle/missions/sts-73/mission-sts-73.h...  \n",
              "3           \"GET /shuttle/countdown/liftoff.html HTTP/1.0\"  \n",
              "4        \"GET /shuttle/missions/sts-73/sts-73-patch-sma...  \n",
              "...                                                    ...  \n",
              "1048570  \"GET /shuttle/missions/sts-70/movies/movies.ht...  \n",
              "1048571     \"GET /shuttle/missions/missions.html HTTP/1.0\"  \n",
              "1048572           \"GET /images/KSC-logosmall.gif HTTP/1.0\"  \n",
              "1048573          \"GET /images/NASA-logosmall.gif HTTP/1.0\"  \n",
              "1048574                 \"GET /htbin/cdt_clock.pl HTTP/1.0\"  \n",
              "\n",
              "[1048575 rows x 3 columns]>"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "id": "kAz8McbzZsV_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from numpy import array\n",
        "from keras.models import Sequential\n",
        "from keras.layers import LSTM\n",
        "from keras.layers import Dense"
      ],
      "metadata": {
        "id": "d_uBCUZiV5L6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# univariate data preparation\n",
        "from numpy import array\n",
        "\n",
        "# split a univariate sequence into samples\n",
        "def split_sequence(sequence, n_steps):\n",
        "\tX, y = list(), list()\n",
        "\tfor i in range(len(sequence)):\n",
        "\t\t# find the end of this pattern\n",
        "\t\tend_ix = i + n_steps\n",
        "\t\t# check if we are beyond the sequence\n",
        "\t\tif end_ix > len(sequence)-1:\n",
        "\t\t\tbreak\n",
        "\t\t# gather input and output parts of the pattern\n",
        "\t\tseq_x, seq_y = sequence[i:end_ix], sequence[end_ix]\n",
        "\t\tX.append(seq_x)\n",
        "\t\ty.append(seq_y)\n",
        "\treturn array(X), array(y)\n",
        "\n",
        "# define input sequence\n",
        "raw_seq = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n",
        "# choose a number of time steps\n",
        "n_steps = 3\n",
        "# split into samples\n",
        "X, y = split_sequence(raw_seq, n_steps)\n",
        "# summarize the data\n",
        "for i in range(len(y)):\n",
        "\tprint(X[i], y[i])\n",
        "print(X.shape)\n",
        "print(X.shape[0])\n",
        "print(X.shape[1])\n",
        "...\n",
        "# reshape from [samples, timesteps] into [samples, timesteps, features]\n",
        "n_features = 1\n",
        "X = X.reshape((X.shape[0], X.shape[1], n_features))\n",
        "# for i in range(len(X)):\n",
        "# \tprint(X[i])\n",
        " \n",
        " \n"
      ],
      "metadata": {
        "id": "kV4SLjn9WM_n",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09d55f80-0584-44af-e8c8-dd8f97ff5013"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10 20 30] 40\n",
            "[20 30 40] 50\n",
            "[30 40 50] 60\n",
            "[40 50 60] 70\n",
            "[50 60 70] 80\n",
            "[60 70 80] 90\n",
            "(6, 3)\n",
            "6\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [1,2,3,4]\n",
        "lst[0:2]"
      ],
      "metadata": {
        "id": "_N19k1rhvnq0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "415e6af0-5c78-4986-e39b-b615bb189d19"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2]"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# univariate stacked lstm example\n",
        "from numpy import array\n",
        "from keras.models import Sequential\n",
        "from keras.layers import LSTM\n",
        "from keras.layers import Dense\n",
        "\n",
        "# split a univariate sequence\n",
        "def split_sequence(sequence, n_steps):\n",
        "\tX, y = list(), list()\n",
        "\tfor i in range(len(sequence)):\n",
        "\t\t# find the end of this pattern\n",
        "\t\tend_ix = i + n_steps\n",
        "\t\t# check if we are beyond the sequence\n",
        "\t\tif end_ix > len(sequence)-1:\n",
        "\t\t\tbreak\n",
        "\t\t# gather input and output parts of the pattern\n",
        "\t\tseq_x, seq_y = sequence[i:end_ix], sequence[end_ix]\n",
        "\t\tX.append(seq_x)\n",
        "\t\ty.append(seq_y)\n",
        "\treturn array(X), array(y)\n",
        "\n",
        "# define input sequence\n",
        "raw_seq = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n",
        "# choose a number of time steps\n",
        "n_steps = 4\n",
        "# split into samples\n",
        "X, y = split_sequence(raw_seq, n_steps)\n",
        "# reshape from [samples,timesteps] into [samples,timesteps,features]\n",
        "n_features = 1\n",
        "X = X.reshape((X.shape[0], X.shape[1], n_features))\n",
        "# define model\n",
        "model = Sequential()\n",
        "model.add(LSTM(50, activation='relu', return_sequences=True, input_shape=(n_steps, n_features)))\n",
        "model.add(LSTM(50, activation='relu'))\n",
        "model.add(Dense(1))\n",
        "model.compile(optimizer='adam', loss='mse')\n",
        "# fit model\n",
        "model.fit(X, y, epochs=200, verbose=0)\n",
        "# demonstrate prediction\n",
        "x_input = array([60,70, 80, 90])\n",
        "x_input = x_input.reshape((1, n_steps, n_features))\n",
        "yhat = model.predict(x_input, verbose=0)\n",
        "print(yhat)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z2KiYnwsU8YQ",
        "outputId": "4a91c67c-5767-4fee-a919-2f40a727e9b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[103.56283]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.head"
      ],
      "metadata": {
        "id": "1QbaBY-EXbyS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e36d6e29-8479-4b54-c143-3accedafe5a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<bound method NDFrame.head of                         IP Address                     Date/Time  \\\n",
              "0                     199.72.81.55  [01/Jul/1995:00:00:01 -0400]   \n",
              "1             unicomp6.unicomp.net  [01/Jul/1995:00:00:06 -0400]   \n",
              "2                   199.120.110.21  [01/Jul/1995:00:00:09 -0400]   \n",
              "3               burger.letters.com  [01/Jul/1995:00:00:11 -0400]   \n",
              "4                   199.120.110.21  [01/Jul/1995:00:00:11 -0400]   \n",
              "...                            ...                           ...   \n",
              "1048570  ix-atl10-28.ix.netcom.com  [14/Jul/1995:10:05:59 -0400]   \n",
              "1048571              198.133.29.18  [14/Jul/1995:10:05:59 -0400]   \n",
              "1048572              192.68.108.59  [14/Jul/1995:10:06:00 -0400]   \n",
              "1048573              192.68.108.59  [14/Jul/1995:10:06:00 -0400]   \n",
              "1048574         oregon.oxmol.co.uk  [14/Jul/1995:10:06:00 -0400]   \n",
              "\n",
              "                                                   Request  \n",
              "0                          \"GET /history/apollo/ HTTP/1.0\"  \n",
              "1                       \"GET /shuttle/countdown/ HTTP/1.0\"  \n",
              "2        \"GET /shuttle/missions/sts-73/mission-sts-73.h...  \n",
              "3           \"GET /shuttle/countdown/liftoff.html HTTP/1.0\"  \n",
              "4        \"GET /shuttle/missions/sts-73/sts-73-patch-sma...  \n",
              "...                                                    ...  \n",
              "1048570  \"GET /shuttle/missions/sts-70/movies/movies.ht...  \n",
              "1048571     \"GET /shuttle/missions/missions.html HTTP/1.0\"  \n",
              "1048572           \"GET /images/KSC-logosmall.gif HTTP/1.0\"  \n",
              "1048573          \"GET /images/NASA-logosmall.gif HTTP/1.0\"  \n",
              "1048574                 \"GET /htbin/cdt_clock.pl HTTP/1.0\"  \n",
              "\n",
              "[1048575 rows x 3 columns]>"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from pandas import read_csv\n",
        "import math\n",
        "import tensorflow as tf\n",
        "import pandas as pd\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "dataset = pd.read_csv('/content/gdrive/My Drive/output2.csv', usecols=[1], engine='python')\n",
        "plt.plot(dataset)\n",
        "plt.show()\n",
        "# convert an array of values into a dataset matrix\n",
        "def create_dataset(dataset, look_back):\n",
        "\tdataX, dataY = [], []\n",
        "\tfor i in range(len(dataset)-look_back-1):\n",
        "\t\ta = dataset[i:(i+look_back), 0]\n",
        "\t\tdataX.append(a)\n",
        "\t\tdataY.append(dataset[i + look_back, 0])\n",
        "\treturn np.array(dataX), np.array(dataY)\n",
        "\n",
        "# normalize the dataset\n",
        "scaler = MinMaxScaler(feature_range=(0, 1))\n",
        "dataset = scaler.fit_transform(dataset)\n",
        "# split into train and test sets\n",
        "# train_size = int(len(dataset) * 0.63)\n",
        "# val_size=int((len(dataset) - train_size)*0.75)\n",
        "# test_size = (len(dataset) - train_size) - val_size\n",
        "# train, test ,val= dataset[0:train_size,:], dataset[train_size:train_size+val_size,:],dataset[train_size+val_size:len(dataset),:]\n",
        "train_size = int(len(dataset) * 0.70)\n",
        "test_size = len(dataset) - train_size\n",
        "train, test = dataset[0:train_size,:], dataset[train_size:len(dataset),:] \n",
        "plt.plot(train)\n",
        "plt.show()\n",
        "\n",
        "# plt.plot(val)\n",
        "# plt.show()\n",
        "\n",
        "plt.plot(test)\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "# reshape into X=t and Y=t+1\n",
        "look_back = 15\n",
        "trainX, trainY = create_dataset(train, look_back)\n",
        "testX, testY = create_dataset(test, look_back)\n",
        "#valX, valY = create_dataset(val, look_back)\n",
        "print(trainX[:5])\n",
        "print(trainY[:5])\n",
        "#print(valX[:5])\n"
      ],
      "metadata": {
        "id": "aq12uLDNas0m",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "c0cc6acc-3b60-4bfd-e2f7-942fb119ba9e"
      },
      "execution_count": 30,
      "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"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD4CAYAAAAAczaOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxmklEQVR4nO3dd5hTVfoH8O87jd4ZkD50RFS6gA1ElKKgrruCa8FV2VUsu+7qD0SxoaLu2hZWRcVdXRULFlZQEEEpShmKVIERBpgBhs7Qhmnn90duMjfJTXKT3OTeTL6f5+EhublJzs3cvDn3nPecI0opEBFRckixuwBERBQ/DPpEREmEQZ+IKIkw6BMRJREGfSKiJJJm1xs3bNhQZWVl2fX2REQJadWqVQeVUpmRPt+2oJ+VlYXs7Gy73p6IKCGJyM5ons/mHSKiJMKgT0SURBj0iYiSCIM+EVESYdAnIkoiIYO+iEwXkf0isiHA4yIir4pIjoisE5Hu1heTiIisYKam/28Ag4M8PgRAe+3fGACvRV8sIiKKhZBBXym1CMDhILuMAPCuclkGoK6INLGqgETkfJv3FmLVziN2F4NMsKJNvxmA3br7edo2PyIyRkSyRST7wIEDFrw1ETnBkFcW4zev/Wh3MciEuHbkKqWmKaV6KqV6ZmZGPIqYiIgiZEXQzwfQQne/ubaNiIgcxoqgPwvALVoWTx8Ax5RSey14XSIisljICddE5EMA/QE0FJE8AI8BSAcApdTrAOYAGAogB8ApALfFqrBERBSdkEFfKTUqxOMKwFjLSkRERDHDEblEREmEQZ+IKIkw6BMRJREGfSKiJMKgT0SURBj0iYiSCIM+EVESYdAnIkoiDPpEREmEQZ+IKIkw6BMRJREGfSKiJMKgT0SURBj0iYiSCIM+EVESYdAnIkoiDPpEREmEQZ+IKIkw6BMRJREGfSKiJMKgT0SURBj0iYiSCIM+EVESYdAnIkoiDPpEFJVtBcftLgKFgUGfiKLym9d+tLsIFAYGfSKKWFFJGQqLSu0uBoWBQZ+IIsZafuJh0CeiiBw+WYyNewrtLgaFiUGfiCIyZUGO3UWgCDDoExElEVNBX0QGi8gWEckRkXEGj7cUkYUiskZE1onIUOuLSkRE0QoZ9EUkFcBUAEMAdAYwSkQ6++z2CICPlVLdAIwE8C+rC0pERNEzU9PvDSBHKbVdKVUMYAaAET77KAC1tdt1AOyxrohERGQVM0G/GYDduvt52ja9xwHcJCJ5AOYAuNfohURkjIhki0j2gQMHIiguERFFw6qO3FEA/q2Uag5gKID3RMTvtZVS05RSPZVSPTMzMy16ayIiMstM0M8H0EJ3v7m2Te92AB8DgFLqJwBVATS0ooBERGQdM0F/JYD2ItJaRDLg6qid5bPPLgADAUBEzoYr6LP9hojIYUIGfaVUKYB7AMwFsBmuLJ2NIvKkiAzXdvsrgDtF5GcAHwIYrZRSsSo0ERFFJs3MTkqpOXB10Oq3TdTd3gTgQmuLRkREVuOIXCKiJMKgT0SURBj0iYiSCIM+EVESYdAnoogcOnnG7iJQBBj0iSgih08W+21bveuIDSWhcDDoE1FEqqT5h4/s3MM2lITCwaBPRBESuwtAEWDQJyJKIgz6RBSRzXv9F0Xfffi0DSWhcDDoE1FE8o/6B3ijbeQsDPpEZBnOs+h8DPpEZBmGfOdj0CeisH28crfh9nJGfcdj0CeisD00c53dRaAIMegTkWXqVEu3uwgUAoM+EVmmZpVUu4tAITDoE5FlmLzjfAz6RGSZjXv8B2yRszDoE5Fldh85ZXcRKAQGfSKyTN82DewuAoXAoE9ElmGbvvMx6BORZRTH5Doegz4RWYY1fedj0CciyzDmOx+DPhFZhjV952PQJyILMeo7HYM+EVmmX9uGdheBQmDQJ6KwFJWUBXysXg1OuOZ0DPpEZBm26TufqaAvIoNFZIuI5IjIuAD7/E5ENonIRhH5wNpiElEiYNB3vrRQO4hIKoCpAAYByAOwUkRmKaU26fZpD2A8gAuVUkdEpFGsCkxEzsWY73xmavq9AeQopbYrpYoBzAAwwmefOwFMVUodAQCl1H5ri0lEThGsNs+F0Z3PTNBvBkC/IGaetk2vA4AOIrJURJaJyGCjFxKRMSKSLSLZBw4ciKzERORYL3271e4iUAhWdeSmAWgPoD+AUQDeFJG6vjsppaYppXoqpXpmZmZa9NZE5BR7jhXZXQQKwUzQzwfQQne/ubZNLw/ALKVUiVJqB4CtcP0IEBGRg5gJ+isBtBeR1iKSAWAkgFk++3wBVy0fItIQruae7dYVk4iIrBAy6CulSgHcA2AugM0APlZKbRSRJ0VkuLbbXACHRGQTgIUAHlRKHYpVoYnIuQ6eOGN3ESiIkCmbAKCUmgNgjs+2ibrbCsAD2j8iSmJfrMnHHRe3sbsYFABH5BKRpUTE7iJQEAz6RBSWLQXHgz7OkO9sDPpEFJat+4IHfV/l5QrzNu7jwC2HYNAnorA8NHNd0Mf3Hjvtdf+9ZTsx5r1V+Gy1b6Y32YFBn4gs9ebiHV7392g/AgXHOXDLCRj0iSimhK38jsKgT0SWe/SLDcgaNxuz1+2FO5mHTfrOwKBPRJZ7b9lOAMD0pTtYz3cYBn0iiguj7J3//bwHWeNmY38h2/vjhUGfiGIq2FitGSt3AQC2FpyIU2mIQZ+I4sKoTd/dyVvOBv+4YdAnopgpLi0P2oHr6eSNT3EIJidcIyKKxPr8Y1iffwyAcWBPEdb04401fSKKi9MlZTh5ptRzv7i0HKdLygBwbd14YtAnorh47ftfcc5jcz33r5m6FCt2HAbAHP54YtAnIlts2lvouc2gHz8M+kRkO7bpxw+DPhHZrpwxP24Y9InIARj144VBnyjGcvYfx5nSMruLYYmjp4pj8rps3YkfBn2iGDp44gwuf3ERHv1ig91FscRHK3fH5HUZ8+OHQZ8oho4XufLS3amJic6q4Jyd6/15sKYfPwz6RHHAmObtoU+9l1xk9k78cBoGohiqTHPJT12YgxfmbrHmxXw+GIb8+GFNn4hMsSzgw//HkNMwxA+DPhHFVVm5gvhMsl9cWm5TaZIPgz4RxZVR+upz3/zit21d3lFkjZuNPUdPx6NYSYNBn8gC2bmHkXvwZMDH2Xrhzbd55+CJYhSXliNr3Gx8kr0bY99fjeFTlgIAFm09EP8CVmLsyCWKwIvfbsX0JTuw4YkrAQDXv/4TACB38jD0f2Eh8o+eRkmZwry/XGJnMR1JKeMlFN0Dv56fuwUHjp+p2D9eBUsSDPpEEXj1u20BH8s9dMpz++CJMwH3S1ah0jN5VRRbbN4horgqVxVr4xrx/aHkj4C1TAV9ERksIltEJEdExgXZ7zciokSkp3VFJEpc7uCm2EjhUV6uDJt3AuFnZ62QQV9EUgFMBTAEQGcAo0Sks8F+tQDcD2C51YUkosqDo2/tZaam3xtAjlJqu1KqGMAMACMM9nsKwHMAiiwsH1FCYy3V39HTJSgNYwJ9/kZYy0zQbwZAP7VenrbNQ0S6A2ihlJod7IVEZIyIZItI9oEDTMMi51q7+yi+XJtv2esxcFUY+I8fkLP/hN/2xdsOGu7Pj85aUWfviEgKgBcBjA61r1JqGoBpANCzZ0/+LcmxrpnqyhEf0bVZiD3NYdAP7a+f/Gy4nVM0WMtMTT8fQAvd/ebaNrdaALoA+F5EcgH0ATCLnbmUDBiQKNGYCforAbQXkdYikgFgJIBZ7geVUseUUg2VUllKqSwAywAMV0plx6TERA7CtV1jj7+r1goZ9JVSpQDuATAXwGYAHyulNorIkyIyPNYFJHKycqWw81Dg6RfYIB09Xk1Zy1SbvlJqDoA5PtsmBti3f/TFIqd7a/F2dGhcC5d0yLS7KLZSCngkyFKIDFfRm/r9rxh9YWu7i1FpcEQuRWTS7M24ZfoKu4thi8lfV8wIWa5UwKwTwLtpYkeQCdkoMP08PIkq78gpx0wfzaCvk3/0NI4XldhdDHK413/41XM7VMuDO08//+hpDPj795amgVJiOHGmFBc9txDjPlsXeuc4YNDXuXDyAgyfshS7D5/CLdNX4OSZUruL5EhFJf7zoScr39GlZT49u74/Chvyj8W6SJXS+M/W212EiJ0udn1fnDJFNIM+gPGfrfPUwHYcPInn527Boq0HMH9zgc0lc6alOYGbM5KN7xfZtynC90eBfZKR+XDFLruLEDGnjcpm0Afw4YrduH/GWruL4ViHTxZjyCuLPVkqKeHMllXJbfdpp/f9gjvr607EoI/Vu47YXQTHm71+LzbvLcS0RdsBGC+AkazKQyTqf5qdF6eSkFMFm0baDgkb9O+fsQYvfrs1oudOWbANd7+/CgAw6atNfo8zL7jCVf9cjP+t3QMAeH+56xI7mWv6vueGb8xfn+fdZj97/V7v58ekVORkTmveSdiVs77UAtEDgzqE/dy/z3P9WJSUlWP1rqMB95MkCW4Pf74epWXleP768722K6WwIb/Qb/9kDPqPz9qIY6dL8I/fen9Gvm32Y95bFc9iUUJxxvcmYWv6Vgh1pVCZa/x5R06h7cNz8Mu+QnywfBc+NmiGCHT4+pifNS7oxKqVxr9/zMXna/L96mzhzg2fqKdUZciVJ5ekDvpBh89XcvM2FqCsXGHGit1e25+ZsxnDpywBELgpYt8x/yUThr262GvQUmXyxZqK3PopC3K8HgtnXvhEtv2A/1TIlJgqddBf8EsBDgVZmHrO+n1Bn58szTt60xZtxzqtXTpQLdZoCtyNewq9Bi1VJpNmb/bcfmm+99VhqI5cX9v2H7ekTPH29Ybg3xVf13W3ZkrqSsFh9YJKG/RPF5fhD//O9psqQF9rC8Rdk/3p1+TOR0/UpgirBfvt9x2MFUqgKRuenr0J3Z/6NqzXcrJzmtZB7uRhdheDDFTaoF9a7prnYuehU55tP+8+ij9/tDbkc7N3utI4P/Rp+kgmv+wrNMw6SLa23RvfXBb0mK1q3nlz8Q4cPllsyWvFQrjzBqXadJF88MQZ/O/nPfa8eSAOazCotEHf6KtodlqFJGzVAQDc8MZPntu3Tl+BMwYTRPV6en48i2S7H389FPTxM6XJMSXFD2FOIZCSYs+X6Pb/ZOPeD9cEbdaNtwue+c7uInipVEH/0S82eLJJVmu1df2pZ7ZOVtljfta42XjSYHzC8h2HPbcLCs/glfnbwn7tnARts45UMl8NBhOLtN7CohJc9c/FhokEbnuOngbgnA72bQXHPc2kTqlMVqqg/96ynZ7bo99ZCQA4rqvdm22jdsbpYr+3l+wwtd8Fz1TU/lfmHsHy7YeweJtxzfBP761yfJpnvFJ1K3NKsDvAzX/gEste8/4P12BDfiH6PBu45uyOq075aJfpKlIA8En2btuzBitF0F+fdyxoO55SCiVl5aZHxjnlhImHkrLo5/guKPS+lL5h2jLc/LbxXPvfbAwvCySeysoVlm8/hNbj54TeOQqLtx3AjzkH0Xr8HPy8+2hM38su7pp+u0a1LHvNhVtCNzE5pTbt4RNMHvx0HS594Xt7yqKpFEH/6ilLcO+HawI+/p8fc9F+wtdJ1wlphntqBQIufm4Bbpi2LObvc/PbKzBjpatZ6J4PVwfdt6ikLCGvCOyOvU6Z+kBfCqf8HStF0A9l8jeuQUOVNY+crLEnSFux1XYddmWV7T58OuCKSvsLi9Dp0W9MN7M5iV0duU6b3Gzz3oo+Lqf0M1TKoO+bpVNU4vpSbS3gqEJyBn0zRP8XFhrus/uIq1Pyq3V7DR93svQY52y6v+NKKbw4bwvyjpzyetwhlWqvwXvhjumIlYQP+qUGbdJWtFO7/bLPf8IxCuwgm9BM0We3BLrCcEr7tFOCld45j80FAGzbfwKvLsjBXf91NZM55TNz05dHXxm1M9U34YO+Uf5w1yetG9k4+OXFlr1WMvhHhNNdJ5twYtPa3UcxbZGraXJd3lH88zv/VNqSsnLsP25989TsdXvR9uHYdmxHwz1ViG8QdcrPlD7o63873bME2yHhg348LuMKE2yx9HeW7sCCXwqwteA4O69NivdgHveo72D0PwzPzHH1Sw2fstTwh3XC5+vR++nvLF+/eOwHwTuazbj9otb47+0XWFAaf+42fE8uvLbdKZ2mgdhZvoSdT98tHpdz5z0+L6HmEXnif94Dr/Rld/qXwS7Pf7PF7iKE7b/LdqJGlVRc2605vtEmRDtTUo6q6alRv/aeo6dRv0ZG1K8DAI9e1dmS1zHi/v4rz31nte8cPOG8qTUSPuhTeOLZPFtYVIITRaVoWrda/N40Qo5J8VPKE7hC/a0e+WIDAODabs0tL0e/yQvQr20Dy1/XaoFCvFHdZmvBcbRvVDOuPwzVM4x/gO3MMkr45p3TFl/OVnZfb4hfJsiQlxej3+QFcXu/yuDTVYHX1D12qqKZMR5XbKHmHbLb/TPWoLDI3Hxaq3YewRUvLcK/vmfadsLX9O/5IPCgLHLZf7wIL87bisXbDiJfm5skHuL5XpXFf5ftxG97ttDueQf285+c57mtz/92onjUZL9cu8fTIer7I7hix2E8+uUGvH1rL9w3Yw1KtLEQL8zdgrED2sW8bCHZ2AqV8EE/XsrKFVJtGnASrd5PO2uWPwrMPWgLCJ6kMPTViqyy4VOWeK54HdNMFedyVLTpu/53L/Rz8MQZzLZpnENhUQm2OXBsUMI378TLK/O34ieHX+5S5FbvOmp3EQAAR3RNOMdNNl2syzuGkjJX2Lv8xR9w8MQZrNp5OMSzKqe8I95Xl77LW8bTTW8tx6a9xuN87Kw+JmTQt2OSqlcX5GDUm8vwY07o1bRue2cF3lq8PQ6lSgyfrwncTu0Euw+fQs5+59XI7nw3O+znHDxRjMEvL8JvXvvJb5RqPMW9ozLAhYV+5t14mbkqDxvyj3mWHXUaU0FfRAaLyBYRyRGRcQaPPyAim0RknYh8JyKtrC9qBd91SuOpQBsA0+/Z75A1brZhDv/CLQcwafZmjubV/OUj/zV1neTYaWeNw3CfU5HO1eJOExz4jx8sK5MZaWE2f758Q1fL3jucT2rt7qM47/G5MVup7K+f/Iyr/rkk6D52ppaGDPoikgpgKoAhADoDGCUivom3awD0VEqdB+BTAM9bXVA9O1PN3TUY99D5qUEuHzmat8L8TQXo+MjXdhfDUKAF4O1y3uPzLFlzwGjls1gKN45d0826xdOVUpixwtyMsa9//ysKi0qxfLv1zbXZuc5vVjNT0+8NIEcptV0pVQxgBoAR+h2UUguVUu5ryWUArE8cdqg3Fm1H24fn4HQxU0eDuePdbK8gdFAbAftjzkHsL/SfPuDYqRJkjZuN77fsj3nZHBbzKULjPltvar9YdjIfdNAyjYGYCfrNAOjXhMvTtgVyOwDDKp2IjBGRbBHJPnAgvDU3nWJF7mG/WlhZucKeY6cxctpPuPv9VX7PWZd3FJsDdOgkK/dylje+tRwjpi4FAKzZdQRbC1ypiJu1prF/LYx9XnVljvnfbNgbt2lEmterHpf3sUosWljMViAqTUeuiNwEoCeAF4weV0pNU0r1VEr1zMzMjPh97PySfhBk0ZFl2w9jznr/laGGT1mKIa+wqSeQvVpT2bX/+hFXvLQIX6zJx0htMZN4pP6t2FF5s7L+9N/VeMBkn8oDH63FZf/4PuL3mjGmT8TPjVY4Z8mOg/YuV2g3M0E/H0AL3f3m2jYvInI5gAkAhiulYnqN48T5Y5xSpE6POrPd3JcCvBYP0V89TVlY0U8S68/1200FnsnMKiujLB6lFD5euRsndNP9frYmH9sPRBYQ+7VtgMa1q0ZcxuuibN/PP2J+IKB7XY01u44ia9xsPPv15rhPqmjnFEFmgv5KAO1FpLWIZAAYCWCWfgcR6QbgDbgCfuwbYcnQxj3HPAvGOJ1SwNSFxp3gZpJAfth6AJv2RN9kFklaZKL5Zd9xvL1kB7bsqxjFu2rnETw0cx0mavP32K11wxpRPT+STCf3utpv/LAd4032B4TikLpfUCGDvlKqFMA9AOYC2AzgY6XURhF5UkSGa7u9AKAmgE9EZK2IzArwchRDw14NnibmNIdOGl8QnjxT0Ske6Et06/QVXqNS4y0RJiPTe+qrTbjy5UWe++4RvPstmnrbqiuyUb1b4qt7L7LmxUIoLqsotFVTkN/9fvRTUceaqWkYlFJzAMzx2TZRd/tyi8sVojzxfDezHFkox/rLR2txTbemho/pMyCUUp7mPCdNm3v/wPaOn5AsGHfqsVPSVe0ohZ2ZNnZ+7Ak3IlcphWILl0OMtUDLopWWlXutn5lsTpeUobTM+Pj1qZ0FhWfQevwczFi5G+Xlym95zKkLc2xZ5OaCNt41/VG9WwTY05ncTWhGwceKPrNwf5/d5XHQ73pM2fnNT7ig//aSHVixw/kDINyKio1/oNpN+Br3fOj8S8FYKjMRXNwzdX6+Jh93vJuNdhO8O6pfmLsFT/osGhNrRot+d29ZL+D+GanO+Zp55o/SDsGopp97KPzpG3yzrML93bD9Ki6J6l/OORtN+my1X+KQI2wM1KmoO5d9l+QzSu9MJoVhTn+w4BfjHIFTxeYmJvNVHOGI1aXjLvPbFixoOWXmSwAY9aYrFda9MPvyHYf9JhIsCXAl/drvu8esXCk2B32jv1FpWXnE55aTJVzQd6r7Z6wNuU+PSfNx4PgZPPv15tgXyCIZabE7ReZvtjfRq0OE00I0quWdmnhx+4aGg23qVEsH4Lw+qEVbD2DuxooKh/uHwO2fAaYWqVk1cBeg7zFG2rzjJPfPWIvOE+caPjZ9yQ7MWb8XL87b4sgU8mAY9GPM9+S//vUf8cYP1s/Aedyidm3fIO+kpgkrbSuIfhGS67pX5JZfcU5jv8d91291ilumr8BSn9liy3T9S+5URl9nYpgObHfrzu7Dp/HYlxu8vkez1weeh//Jrzbh7vdX49UFOZE1h9n4Q5Fw3+hEG0331uIdXvfDGUQSjnMfnxd6JxOWjx/odb/MIZ3NweaWLzxt/hK8qKQMD3++HsOnLI26TNd0rQj6taqm+z3ujmNOrAn6Tn08bua6kM85q07FFc7cP19iaXnczTt2xf59hUX4z087MXXhr9h77HRYzTqR/J3ZkRuGRFsT99Xvtnndj3S63HjIrFUF9WpkeG0zk9LXvF7sFz4PNnfREhNrHLh9tjofHyzfFZfzyN3O78S/uG8b9idB1uZ169Ksjud2Zq0qlpfJV0ZqStQjdcO1Lu8o+j67IGCzDuDfN/fQzHU4caYUH2fvDvAMZ0m4oG/Gg1d2tLsIpkU7575SCr8esGYBkEbaF/m+ge3RuHYV7fVDP699o5qWvH+sFBQWeaYbiLYZYfA5Z3luh3qtihpgdO8ZC1vDXMZv6o3enbi+hx7tIXpq+roXbt+4Jl60cM59M8yMvegxab7X/RU7DuPtxTvwfzOtGdUba5Uy6NernhF6J81nd/eLYUlC++nXQzgSxWIOM1fnW7ZYhrs9/4FBHdBXy0M3k1aZmhLf06jIoJYe6HJ8y77juOCZ7zBUm/Au3A7DYec18brv7pwFgL5tGuDmPq3w3G/OM3yu3e3UVvL9HKw+Nid25IZjXd5Ru4tgWqUM+uGkyAXLr46HJ/63Cd2e+hbHi0oiqrGvj/JkO795xSX7P0d189y+qL1rFlQztfhnru0SVRnCdc8H/uMb9Nkobou2HvBMPeBecDzc1MDnfQK6/txKS03BU9d0QdO6gZq3XO8Vj+avRHOe7rwDgBRd1HfaldH6vGMh2+vDbbatmp4aTZGiUqmCfvWMyD7IK3WZF3+6tK1VxQnLuY/Pi/vydgCQqaUfju6X5TUf+vU9miP7kcu92nEDaRTF7IqRMJvqudBnARbXD2t4iQC+PxLpYWQzuZ/qu1i3218u7xBWWZzEbw3cMGJew5oZ+ORPfX1ez7munrIEf5+3Jeg+4U5nUSWGqdChVJqgf2G7BhihZVMoBQzpclbAfWtV8c43nnpjd9za17Wsb9O6VT2vZ6e3Fm/HhM9DtxFGWykKVvFtWLMKqqZ7nyKXdjBeB2Hzk4OjLIn13lma63X/lukr8PoP4S3Kov98/nhJGzw0uJP55wZ57Olru+D+y9uHVRZHiSJKz7yrH6qk2VfTjcTUEIv57Dvmv/qb3h8vaeN1n3PvWKBhzSpeedFTbjQePXh2k9pY9eggr21pqSn4vyGdcHf/thjZqyV+eWow/nNb7xiX2Jj7MnLS7M14P8iCLW6Rzn/uFird7P8Gd8I9A9qhTaZr6tuHh55tuF+1CK+yrKIv/h/fy8Z/fsz122fNrqNhv66+pj9+6NlebfqhBPtBbZvp7M5vvdoGg7KiadNv1SDyaZRb1K+GhjXN99lZKVi6+Lb9wZtmx/t9b5inHzVBRQ2+SloKUgP0DGWkiuEo0+oZaXhocCdkpKWganoq0mwalBRuRmc46Ypur4zsit6t6wOoCNbVMoxHW9aqmo6/XdkRaSZ62rY9PSTssljlsVkbMeHz9fgkezfmbizAY7M2WvK6sepgNDt//Ly/WJsPH4nZ913st83qj8XMab/84YFY+Nf++OsV9mTnPT3bujmeWNMPQ7D84D9f3gEPXtkx7rm9VvKtcetPtMKiEpz/xDws2x7dlL592zTwBLPrezTHg1d2xP0Do29qCKe922rHi0rx/vJdePDT0IOMwhHJnDBdmtXGO7f1QsOaxudqztNDDFeZamfQaR7sx/aVkV2xddIQ3HtZu6DlefF356Nby7rBCx1EiolfPt/kiXNN9AXpVdM6No0Gubmlp6bYVhkDgKKS8oCjlcNl53CdhAv6/QO0KYsIqmWkYuyAdraeGNEa+upiPPdNxfJ9b+pG9K7PO4Zjp0v8BnxFIzVFMHZAu5DNM07LqIgF31x0ILJmjN5ZDTCgYyNMH90Lz1x7rt/j+vPzf/dchAlDz8bLN3TF/AcuxUODvWuxwX5IR3Rthoy0FJzfvG7Q8tSplo7P774wvIPQMfoIfCeY802TbhNm89V13Ztj/JBOpiofkSZsRGtJzkHc++GasJ93c59WftvsnIQv4aJjoJpX/Rr+7XzvjO6FOT6Xpu5ay7y/XII3b+lpfQGjtLXgBF77PninkTsAX/b374O/1iTj5pZoTrfKlHvuy93kdVOflp5tkUz5635K49pVceMFLYPue27zOrjzkja4Rrs6/cOFrb0eb1G/utHTvAaJndOsdtD3iHYGS6NxL/pXnHRNF7xw/flRvUdqiuCPl7b1SmX0Lbb77tXnGS++41RPXeOf0szmHQsYjcId0KkROjf1/kK4L5c7NK6FQZ39J8myyiPDjDs8IzH45UXo/fR8z1TEP2nNO9tDzEMU6LuuFHBL3ywArs+BXESA3MnDMOmac9G7dX10Oiv+n43Z+KyvKTapUw25k4fFqETGnfT6ct7UpxXqVDffwR1KS+2H7rZ+rQ0fN9Pc5HSceycMgQZ/BhvsMHZARe59s4ADaUK782Ljk9CIlT8ov+w7jv3Hz+DPH631bMsaNzvk84J9NYae2wS5k4cFbHf25R5gZDa/uEmd+ObuW0H/eX38x774RptU7L6B7Q2bfmJThugD2sXtG1pQEvvUqZ6O3MnD8Jsezb22+6bPhsuO34r7dM1VGakpnrjAWTbDoL/c/tZkZsODV1bkVj9t0MZq1oRhnT23Q005HE1aWiBnIlz0w80zn04E9YyXR3bD1Bu7mz6up6/tgtzJwwyzT964uYfXfbvHRLgFasp5YFAHv2kIgr5OVGXw35Y7eRhyJw9Dz1YVo8eb1AlceXnv9gswfXTPiiuVKAo07Fzj47bixykadw8I3nltJFC6cSzVrFJRGd369BCMG2J+nEesJF7Q191u37gWVkwYiHf/YD6nvkYVU2vBh9S/o3GHstPMvKtibiH3FzWSSkadaulhBT53PnuHxrXw82NXeD3mexXwiO7H1E61giwSEo5omtCDPfXTu/ohd/IwTLmxW8jgcVmnxuiZ5fqRqB0kIyaUx4efY7jdjr6dcH9ofH+wRvfLQu7kYXhqhPExxYLvImROmITPmrM8jnw/q0a1qvqtZBQPTu7QHDugLfq2aYi01BT0aFUPix4cgMOninHXf1fFrQw9WtU33F4lLcUvs+PsJsE7IuNhVO+WlqWcBuv8DdU8Zqbj+KoAHZlz7rsYGWkVz39kWGdc3D4TPXRXCOGIZT9BRHQfjZnv30s3dPVaCMXdoX1z3ywM79oMa3Ydweh3VlpdSi++0zNUTLfN5h3T3J9hlxAZC74W/q1/2As/PHVNF7TNrGE4kMZ3jp5eWf5fLHfb6pQbu/k9Fkv1qmfgIl27bssG1dG1RV3P/Xifbu6FxC9oXR9bJg1BTd3VVqDPphL01Rk6p2moTJvI+506N62Ndo0qOp+rpqfiSl2Wj+/kcYE8fnVndEzQDv4VEwZi6o3d8eXYC/0WsNd3ANeplo7+HRvFtCxV01P8Mo1Y04/AbRdmYe7GfZh+a6+wnmd2BKTezX1a4eY+rXD4ZDF2HvLOlOnmMztnsMEWwQacxJNVKzktfmgAThWXeWaw1Jt930VoUMO7c7h6Rho++VNfdDTIhgnUN3JL3yz822AqhVioWz0do/tlxfx9ruveDI9dHbxpQUSwdNxlpjrqw/W7Xi2w91gRXpq/FQDw0OCOeP4b/4nERl/YGqN9Ukf9yxn++/80/jIcORn5sp769wz09o1qVfU0Q+rP85oBmnVrZKTiZLH1C+osf3ig4QA8z1QxTNk0r0PjWlj96KC4zuxYv0aGJ8gvf3igp3Nyki7/9pTuxPGd0A2Ib0aFfrZMvUhyzo20qF/dMIADwDlN63gtq+fWK6u+6bblaT4dvbG2duIVAY8nEr6fsnu06aPDOoc1d08suE+B7i3r4o+XtMXlZ3vXdt0TD4Z8nQg6cpvUqeaXQh1LZs737x8cYPn7nt+8jmHAB3T9apa/q3kJF/Tt1rh2VU9u+026kXb6+XwWPtjf73nRpIqGo2p6CgYHmWEUsK6W8cCgDrjjIvNprIZl8bmfO3kYrtA1Sfz+gpaOaPMPS4BY44T88iztivf3F7RCaorgrv7eWTD92pmrnNjTkat///AKEOjqNhbLPgb7elXU9Nmmn9A6Nq7lmYnwjZt7eHLfJww7G91a1kWvrHqW1iSD6ZVl3IEaC/cNbI9Hroos88adThjq3G+bWRNf338xujSr7XVlZZVQbexWckLn/9XnNcHMu/rhuu7u+am8/wCJOL7CaZ4aEfo8ZU0/gS38W398cldfT/CqoZutstNZtfH53ReiekYaRvfLwiW6eYN+HHeZ57bZDrZoOSHouF19vquDy+wV0Ff3Xoyb+rTyW3EpWoGWOoyGb9OHO1Mj2ukQrCAi6NGqXkUWiS76fHXvRTgvxDw+7kOw40iiaZ58y0QfoH76DQARjcheOu4ynK9LmvDlOQS26Seu1g1roHbVdDw54hxceU5j9GptnB4nIhiqNbvc0LOF19TP+gyLSDXVamihOgoBZ0yedtelbfHNny/GuQGC+N0D2mJAx0y/UZnPXuc/uO6rey+KuBxmVgYLl29scnfyO6B1x4/7VGjVoHpYn4VV/UORMmoeCdYM2Ldt6AGAk6451ysLr01mDcOZT90u6+Sf/ROqEpPigJTNhMvecao2mTXxxs3BJ3Bz56d3b1XX88evmp4ScGqJcMz/66U4dKI44ARdgK490daLS5eUFEGnswJ/SRvVqop3DBaycX8JM1JTsHTcZUhPFdStnoFXR3XDfboZEHMnD8PRU8W498M1WLytYs2BzU8OxoipS7C1IPz1iM0ac7HPFAGeoO+8qF+m/SI1jmCsy9qJg1BSFt25VC09FacNFro3ov/0jN410sVV3rmtl2eBHfdvSZM6VfHIsM6oXS0dx4tK0PfZBX7PGzugLepVz8DM1XkAgJ8nXuG3jy/3KWDn1MoM+nHUu3V9/PBgf7SsXx1HTrlS11JEAg4KalKnKvaGWIYNcI0Orp6Rhur1g/85B3ZqjH//mBvVCE2nEPHuhBt+flMMP78pssbNRp82rn6NutUzkKmbW+jXZ4YiNUU8wXeCxcPy1zw6CCKu99Vzwo9sIOVa9DFb8Zg19iJ8tW4PUgyOMxLLJwxESQTTi1h5tTqgYyMM8MnZf3VUN8+C9zWrpOGRYWejWd1quOv91QCAHx7sj1YNaqBHq/qYuToPaSliatK5aEbFW8VU0BeRwQBeAZAK4C2l1GSfx6sAeBdADwCHANyglMq1tqiVg3vumlQt8KSIoGp6Kj4a0wc3TFsGABg/pBMGnt0IrRrUwIHjZzB/cwH2F57B2AHtkH/0FC5/sSI//oFBHbwmdQrmkWFn40+XtkU9g2moE0VGagruGdAOQ841bhJbOeFyr+kU+rRpgM/W5OOd23p5mtRev6kH3v1pJ26PMvPIV6DPVTm4pu8ObGYHKp3bvE7AJjm3QDnxRsKpgEiIqr4VadHuc8T3L3WHdvU2YejZ6Ny0ttccVD9PvML0j6YTrrZD/nVEJBXAVACDAOQBWCkis5RS+rXDbgdwRCnVTkRGAngOwA2xKHCl4e4Q0/6/oE0DrJgwEGXlymsyraZ1q3mmQQaAdo1qYeWEy/HIF+sxd2NBWGutpqWmGObQO8G0m3vgxJnSkPuJCP5mMI22m28K3m97NselHTO98qazGtbAxKvjN9+P++sdbsw3WpvWalkNa2DFwwMtS11c9/gVngpNLPkGzd5Z9XGnb7NaBF66oSveXrID3Vsa983daTC7ZzjTSifKiNzeAHKUUtsBQERmABgBQB/0RwB4XLv9KYApIiLKzmRUp9M+GX2tyOwcQpm1qmBgp8aYu7EAHRonzgLbwVxhQWe2EREJOFAmXqqnp+L4mdKwMl42PnFlwHWerWblQMdYNh3qs6LqVs/AA4M6ID01Bc998wvaNa5pSedy07rV8GiEachmVElLxaDOjT1TldvBTNBvBmC37n4egAsC7aOUKhWRYwAaAPBatVtExgAYAwAtWwZfUaiyq1M9HQ8N7oghXczPXKn3257NcWWXs2wf4UmhfT62Hxb8sj+sZTytmg22Mnhi+Dl4Z+kOv8Vc7hvYHkUlZdh37DT+1L+t4XMnXtXZVOZOvNSpnm77in0SqjIuItcDGKyUukO7fzOAC5RS9+j22aDtk6fd/1Xb56DRawJAz549VXZ2tgWHQESUPERklVIq4l8OM1WPfAAtdPeba9sM9xGRNAB14OrQJSIiBzET9FcCaC8irUUkA8BIALN89pkF4Fbt9vUAFrA9n4jIeUI2HGpt9PcAmAtXyuZ0pdRGEXkSQLZSahaAtwG8JyI5AA7D9cNAREQOY6q3SCk1B8Acn20TdbeLAPzW2qIREZHVOPcOEVESYdAnIkoiDPpEREmEQZ+IKImEHJwVszcWOQBgZ4RPbwif0b6VAI/J+Srb8QA8pkTgezytlFKZgXYOxbagHw0RyY5mRJoT8Zicr7IdD8BjSgRWHw+bd4iIkgiDPhFREknUoD/N7gLEAI/J+Srb8QA8pkRg6fEkZJs+ERFFJlFr+kREFAEGfSKiJJJwQV9EBovIFhHJEZFxdpcnGBGZLiL7tUVm3Nvqi8i3IrJN+7+etl1E5FXtuNaJSHfdc27V9t8mIrcavVc8iEgLEVkoIptEZKOI3F8JjqmqiKwQkZ+1Y3pC295aRJZrZf9Im1YcIlJFu5+jPZ6le63x2vYtInKlTYfkLkuqiKwRka+0+4l+PLkisl5E1opItrYtYc87rSx1ReRTEflFRDaLSN+4HJNSKmH+wTW1868A2gDIAPAzgM52lytIeS8B0B3ABt225wGM026PA/CcdnsogK/hWju5D4Dl2vb6ALZr/9fTbtez6XiaAOiu3a4FYCuAzgl+TAKgpnY7HcByrawfAxipbX8dwF3a7bsBvK7dHgngI+12Z+18rAKgtXaeptp47j0A4AMAX2n3E/14cgE09NmWsOedVp7/ALhDu50BoG48jsmWg43iQ+oLYK7u/ngA4+0uV4gyZ8E76G8B0ES73QTAFu32GwBG+e4HYBSAN3Tbvfaz+di+BDCoshwTgOoAVsO1BvRBAGm+5x1c60r01W6nafuJ77mo38+G42gO4DsAlwH4Sitfwh6P9v658A/6CXvewbW64A5oyTTxPKZEa94xWqS9mU1liVRjpdRe7fY+AI2124GOzZHHrDUDdIOrZpzQx6Q1hawFsB/At3DVao8qpUq1XfTl85Rde/wYgAZw1jG9DOAhAOXa/QZI7OMBAAVgnoisEpEx2rZEPu9aAzgA4B2tGe4tEamBOBxTogX9SkW5fpoTLmdWRGoCmAngz0qpQv1jiXhMSqkypVRXuGrIvQF0srdEkRORqwDsV0qtsrssFrtIKdUdwBAAY0XkEv2DCXjepcHV9PuaUqobgJNwNed4xOqYEi3om1mk3ekKRKQJAGj/79e2Bzo2Rx2ziKTDFfDfV0p9pm1O6GNyU0odBbAQruaPuiLiXllOXz5P2bXH6wA4BOcc04UAhotILoAZcDXxvILEPR4AgFIqX/t/P4DP4fpxTuTzLg9AnlJquXb/U7h+BGJ+TIkW9M0s0u50+kXkb4WrXdy9/Ratl74PgGPaZd5cAFeISD2tJ/8KbVvciYjAtR7yZqXUi7qHEvmYMkWkrna7Glx9FJvhCv7Xa7v5HpP7WK8HsECrkc0CMFLLhmkNoD2AFXE5CB2l1HilVHOlVBZc348FSqnfI0GPBwBEpIaI1HLfhut82YAEPu+UUvsA7BaRjtqmgQA2IR7HZFfHTBQdIEPhyhr5FcAEu8sToqwfAtgLoASuX/bb4Wov/Q7ANgDzAdTX9hUAU7XjWg+gp+51/gAgR/t3m43HcxFcl5vrAKzV/g1N8GM6D8Aa7Zg2AJiobW8DV5DLAfAJgCra9qra/Rzt8Ta615qgHesWAEMccP71R0X2TsIej1b2n7V/G93f+0Q+77SydAWQrZ17X8CVfRPzY+I0DERESSTRmneIiCgKDPpEREmEQZ+IKIkw6BMRJREGfSKiJMKgT0SURBj0iYiSyP8DW/y9AQXevpMAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0.14851485 0.13861386 0.17326733 0.17079208 0.13118812 0.12623762\n",
            "  0.16584158 0.11386139 0.11138614 0.12376238 0.17326733 0.13613861\n",
            "  0.10643564 0.0470297  0.00990099]\n",
            " [0.13861386 0.17326733 0.17079208 0.13118812 0.12623762 0.16584158\n",
            "  0.11386139 0.11138614 0.12376238 0.17326733 0.13613861 0.10643564\n",
            "  0.0470297  0.00990099 0.20049505]\n",
            " [0.17326733 0.17079208 0.13118812 0.12623762 0.16584158 0.11386139\n",
            "  0.11138614 0.12376238 0.17326733 0.13613861 0.10643564 0.0470297\n",
            "  0.00990099 0.20049505 0.12623762]\n",
            " [0.17079208 0.13118812 0.12623762 0.16584158 0.11386139 0.11138614\n",
            "  0.12376238 0.17326733 0.13613861 0.10643564 0.0470297  0.00990099\n",
            "  0.20049505 0.12623762 0.15346535]\n",
            " [0.13118812 0.12623762 0.16584158 0.11386139 0.11138614 0.12376238\n",
            "  0.17326733 0.13613861 0.10643564 0.0470297  0.00990099 0.20049505\n",
            "  0.12623762 0.15346535 0.19554455]]\n",
            "[0.20049505 0.12623762 0.15346535 0.19554455 0.19554455]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# reshape input to be [samples, time steps, features]\n",
        "\n",
        "trainX = trainX.reshape( (trainX.shape[0], trainX.shape[1], 1))\n",
        "testX = testX.reshape( (testX.shape[0],trainX.shape[1], 1))\n",
        "#testY=testY.reshape((trainY.shape[1],trainY.shape[0]))\n",
        "#valX = valX.reshape( (valX.shape[0],valX.shape[1], 1))\n",
        "print(trainX.shape)\n",
        "print(trainY.shape)\n",
        "print(testX.shape)\n",
        "print(testY.shape)\n",
        "#print(valX.shape)"
      ],
      "metadata": {
        "id": "ouoxcdD2kbQU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c4fee59-0e5f-4009-d42f-6bbb07c01055"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(13465, 15, 1)\n",
            "(13465,)\n",
            "(5762, 15, 1)\n",
            "(5762,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "ZmRPTJfnka-2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# univariate bidirectional lstm example\n",
        "from numpy import array\n",
        "from keras.models import Sequential\n",
        "from keras.layers import LSTM,GRU\n",
        "from keras.layers import Dense\n",
        "from keras.layers import Bidirectional\n",
        "from keras.layers import *\n",
        "\n"
      ],
      "metadata": {
        "id": "bhKcaVRaNMrB"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Mo8KZc9Zf14r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# define model\n",
        "# create and fit the LSTM network\n",
        "# model = Sequential()\n",
        "# model.add(Bidirectional(LSTM(64, activation='relu'), input_shape=(trainX.shape[1],trainX.shape[2] )))\n",
        "# model.add(Dense(1))\n",
        "# model.compile(optimizer='adam', loss='mse')\n",
        "\n",
        "# model.summary()\n",
        "\n",
        "# model2 = Sequential()\n",
        "# model2.add(Bidirectional(GRU(64, activation='relu'), input_shape=(trainX.shape[1], trainX.shape[2])))\n",
        "# model2.add(Dropout(0.5))\n",
        "# model2.add(Dense(1))\n",
        "\n",
        "# model2.compile(optimizer='adam', loss='mse')\n",
        "\n",
        "# model2.summary()\n",
        "\n",
        "\n",
        "# model4 = Sequential()\n",
        "# model4.add(InputLayer((trainX.shape[1],trainX.shape[2])))\n",
        "# model4.add(GRU(64))\n",
        "# model4.add(Dense(8, 'relu'))\n",
        "# model4.add(Dense(1, 'linear'))\n",
        "# model4.compile(optimizer='adam',loss='mse')\n",
        "\n",
        "# model4.summary()\n",
        "\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import InputLayer, GRU, Dense, Dropout\n",
        "from tensorflow.keras.regularizers import l2\n",
        "from tensorflow.keras.optimizers import SGD\n",
        "\n",
        "# Define the model architecture\n",
        "model = Sequential()\n",
        "model.add(InputLayer(input_shape=(trainX.shape[1], trainX.shape[2])))\n",
        "model.add(GRU(128, return_sequences=True))\n",
        "model.add(LSTM(64))\n",
        "model.add(Dense(8, activation='linear'))\n",
        "model.add(Dropout(0.2))\n",
        "model.add(Dense(1, activation='linear', kernel_regularizer=l2(0.01)))\n",
        "\n",
        "# Compile the model\n",
        "optimizer = SGD(lr=0.01)\n",
        "model.compile(optimizer=optimizer, loss='mean_squared_error')\n",
        "\n",
        "\n",
        "# Fit the model to the training data\n",
        "history = model.fit(trainX, trainY, epochs=20, batch_size=15, validation_data=(testX, testY))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H3DpzHhqeHJJ",
        "outputId": "1486f89d-fb96-469a-8174-c5999bc9107e"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:`lr` is deprecated, please use `learning_rate` instead, or use the legacy optimizer, e.g.,tf.keras.optimizers.legacy.SGD.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "898/898 [==============================] - 37s 35ms/step - loss: 0.0188 - val_loss: 0.0212\n",
            "Epoch 2/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0131 - val_loss: 0.0155\n",
            "Epoch 3/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0099 - val_loss: 0.0119\n",
            "Epoch 4/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0078 - val_loss: 0.0099\n",
            "Epoch 5/20\n",
            "898/898 [==============================] - 33s 37ms/step - loss: 0.0063 - val_loss: 0.0087\n",
            "Epoch 6/20\n",
            "898/898 [==============================] - 31s 35ms/step - loss: 0.0053 - val_loss: 0.0076\n",
            "Epoch 7/20\n",
            "898/898 [==============================] - 30s 34ms/step - loss: 0.0046 - val_loss: 0.0070\n",
            "Epoch 8/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0041 - val_loss: 0.0066\n",
            "Epoch 9/20\n",
            "898/898 [==============================] - 30s 34ms/step - loss: 0.0038 - val_loss: 0.0062\n",
            "Epoch 10/20\n",
            "898/898 [==============================] - 30s 34ms/step - loss: 0.0035 - val_loss: 0.0057\n",
            "Epoch 11/20\n",
            "898/898 [==============================] - 30s 34ms/step - loss: 0.0033 - val_loss: 0.0055\n",
            "Epoch 12/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0031 - val_loss: 0.0053\n",
            "Epoch 13/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0029 - val_loss: 0.0052\n",
            "Epoch 14/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0028 - val_loss: 0.0049\n",
            "Epoch 15/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0027 - val_loss: 0.0047\n",
            "Epoch 16/20\n",
            "898/898 [==============================] - 30s 34ms/step - loss: 0.0026 - val_loss: 0.0046\n",
            "Epoch 17/20\n",
            "898/898 [==============================] - 30s 34ms/step - loss: 0.0025 - val_loss: 0.0044\n",
            "Epoch 18/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0025 - val_loss: 0.0044\n",
            "Epoch 19/20\n",
            "898/898 [==============================] - 31s 34ms/step - loss: 0.0024 - val_loss: 0.0043\n",
            "Epoch 20/20\n",
            "898/898 [==============================] - 30s 34ms/step - loss: 0.0024 - val_loss: 0.0043\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# fit model\n",
        "model2.fit(trainX, trainY, epochs=10, batch_size=10, verbose=0)\n",
        "\n",
        "# from keras.callbacks import EarlyStopping\n",
        "\n",
        "# early_stop = EarlyStopping(monitor='val_loss', patience=10)\n",
        "\n",
        "# model2.fit( trainX, trainY,validation_data=(valX, valY), epochs=15, callbacks=[early_stop])\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 382
        },
        "id": "SzW11oUdZ2FM",
        "outputId": "1b4b7be1-a816-48b2-b0e7-6f444418cc95"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-29-106e869be621>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# fit model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmodel2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrainX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrainY\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# from keras.callbacks import EarlyStopping\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/keras/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     63\u001b[0m         \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     64\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     66\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m             \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m   1648\u001b[0m                         ):\n\u001b[1;32m   1649\u001b[0m                             \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1650\u001b[0;31m                             \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1651\u001b[0m                             \u001b[0;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1652\u001b[0m                                 \u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masync_wait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/tensorflow/python/util/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    148\u001b[0m     \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    149\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    151\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    878\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    879\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jit_compile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 880\u001b[0;31m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    881\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    882\u001b[0m       \u001b[0mnew_tracing_count\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    910\u001b[0m       \u001b[0;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    911\u001b[0m       \u001b[0;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 912\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_no_variable_creation_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    913\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_variable_creation_fn\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    914\u001b[0m       \u001b[0;31m# Release the lock early so that multiple threads can perform the call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/tensorflow/python/eager/polymorphic_function/tracing_compiler.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    132\u001b[0m       (concrete_function,\n\u001b[1;32m    133\u001b[0m        filtered_flat_args) = self._maybe_define_function(args, kwargs)\n\u001b[0;32m--> 134\u001b[0;31m     return concrete_function._call_flat(\n\u001b[0m\u001b[1;32m    135\u001b[0m         filtered_flat_args, captured_inputs=concrete_function.captured_inputs)  # pylint: disable=protected-access\n\u001b[1;32m    136\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/tensorflow/python/eager/polymorphic_function/monomorphic_function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m   1743\u001b[0m         and executing_eagerly):\n\u001b[1;32m   1744\u001b[0m       \u001b[0;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1745\u001b[0;31m       return self._build_call_outputs(self._inference_function.call(\n\u001b[0m\u001b[1;32m   1746\u001b[0m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[1;32m   1747\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/tensorflow/python/eager/polymorphic_function/monomorphic_function.py\u001b[0m in \u001b[0;36mcall\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m    376\u001b[0m       \u001b[0;32mwith\u001b[0m \u001b[0m_InterpolateFunctionError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    377\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcancellation_manager\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 378\u001b[0;31m           outputs = execute.execute(\n\u001b[0m\u001b[1;32m    379\u001b[0m               \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msignature\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    380\u001b[0m               \u001b[0mnum_outputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_num_outputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.9/dist-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     50\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     51\u001b[0m     \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 52\u001b[0;31m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0m\u001b[1;32m     53\u001b[0m                                         inputs, attrs, num_outputs)\n\u001b[1;32m     54\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# fit model\n",
        "model4.fit(trainX, trainY, epochs=10, batch_size=10, verbose=0)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MhmpxPcuBHzt",
        "outputId": "207ddffe-c74e-4a31-c39f-78796a795e81"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f214e7bb790>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# make predictions\n",
        "import time\n",
        "trainPredict = model.predict(trainX)\n",
        "start_time = time.time()\n",
        "testPredict = model.predict(testX)\n",
        "end_time = time.time()\n",
        "# invert predictions\n",
        "trainPredict = scaler.inverse_transform(trainPredict)\n",
        "trainY = scaler.inverse_transform([trainY])\n",
        "testPredict = scaler.inverse_transform(testPredict)\n",
        "testY = scaler.inverse_transform([testY])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EYAb-dIVfS-S",
        "outputId": "c53a6371-2164-4cd5-f152-98aa44b964d6"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "421/421 [==============================] - 6s 11ms/step\n",
            "181/181 [==============================] - 2s 11ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "plt.plot(testPredict)\n",
        "plt.show()\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "aDK13fnqohPg",
        "outputId": "5db27587-95ce-4a19-bc01-3251c3dad9f0"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAD4CAYAAAAKA1qZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABFdUlEQVR4nO2dd5hU1fnHv++U7cAusPSygCACSnEDEhVUFBFN1FgiSdSoCdFoYklD/VliEjVGY2zRYOwxdo0FFRGxoCgCAtJ7lbII7C5bp5zfH/eeO2fu3Ck7c6fc2ffzPPvsnXNnZs+dvXPe83YSQoBhGIZpn7iyPQGGYRgme7AQYBiGacewEGAYhmnHsBBgGIZpx7AQYBiGacd4sj0BAOjatauoqqrK9jQYhmEcxeLFi/cJISpTeY+cEAJVVVVYtGhRtqfBMAzjKIhoa6rvweYghmGYdgwLAYZhmHZMXCFARH2JaB4RrSKilUR0tT7emYjmENF6/XeFPk5EdD8RbSCi5UQ0Jt0XwTAMwyRHIpqAH8BvhBDDABwD4EoiGgZgBoC5QojBAObqjwHgNACD9Z/pAB62fdYMwzCMLcQVAkKIXUKIJfpxPYDVAHoDOBPAU/rTngJwln58JoCnhcbnAMqJqKfdE2cYhmFSp00+ASKqAjAawBcAugshdumndgPorh/3BrBdedkOfcz8XtOJaBERLaqpqWnrvBmGYRgbSFgIEFEZgFcAXCOEqFPPCa0UaZvKkQohZgohqoUQ1ZWVKYW5MgzDMEmSkBAgIi80AfCsEOJVfXiPNPPov/fq4zsB9FVe3kcfYxgmj9lUcwjz1+/L9jSYNpJIdBABeAzAaiHE35VTbwC4WD++GMDryvhFepTQMQBqFbMRwzB5ykn3fISfPPYFAODtr3dhb11zlmfEJEIiGcPHArgQwNdEtFQfuwHAnQBeJKLLAGwFcL5+7m0AUwFsANAI4BI7J8wwTG7T4g/gl88uwaDKUsz9zQnZng4Th7hCQAgxHwBFOT3J4vkCwJUpzothGIfS4g8CADbWNGR5JkwicMYwwzC20qoLAcYZsBBgGMZWDjb6AAAUzX7A5BQsBBiGsZUHPlgPAHCzFHAELAQYhrGV/l1KAQBuFwsBJ8BCgGEYW+haVqgdCC1v1MNCwBGwEGAYxhbc+mpS3+IHALhYCDgCFgIMw9iCS/cBzF6xGwCbg5wCCwGGYWxBLvnf1GqZwi52DDsCFgIMw9hCmypIMjkDCwGGYWxBCPNjFgtOgIUAwzC2IEy6QJBlgCNgIcAwjC3wou9MWAgwDGMLbA5yJiwEGIaxCRHjEZOrsBBgGMYWIjb+LAUcAQsBhmFsIShYE3AiLAQYhrGFCEWAfQKOgIUAwzC2EOEYzs40mDbCQoBhmJRZsbMWtU2+sDFWBJxBXCFARI8T0V4iWqGMvUBES/WfLbIBPRFVEVGTcu6RNM6dYZgc4YwH5keMmZPHmNwkbqN5AE8CeBDA03JACPFDeUxE9wCoVZ6/UQgxyqb5MQzjUFgTcAZxhYAQ4mMiqrI6R0QE4HwAJ9k8L4ZhHA7LAGeQqk/geAB7hBDrlbEBRPQVEX1ERMdHeyERTSeiRUS0qKamJsVpMAyTLfyBoPUJlgKOIFUhMA3Ac8rjXQD6CSFGA7gOwH+JqKPVC4UQM4UQ1UKI6srKyhSnwTBMtmj0BSzH2SfgDJIWAkTkAfADAC/IMSFEixDiW/14MYCNAIakOkmGYXKXplZrIeDninKOIBVN4GQAa4QQO+QAEVUSkVs/HghgMIBNqU2RYZhcpkHvKWxGCCDIgiDnSSRE9DkACwAcTkQ7iOgy/dQFCDcFAcAEAMv1kNGXAVwuhNhv43wZhskxGqNoAgBrA04gkeigaVHGf2ox9gqAV1KfFsMwTiGWEAiwEMh5OGOYYZiUaGi1NgcBQGOMc0xuwEKAYZiUaI6hCRw0lZJgcg8WAgzDpEQsc9ChZtYEch0WAgzDpERTlDwBAPhyC8eF5DosBBiGSYloeQIA8OC8DRmcCZMMLAQYhkkJK03g3xdVAwAuO3ZApqfDtBEWAgzDpIRVslhJoRsuApr90bUEJjdgIcAwTErUNUdGALmJUFboQUMLC4Fch4UAwzApsX7PoYgxt4vQociLeo4OynlYCDAMkxJWmgDpmsChFs4TyHVYCDAMkxIeV+Qy4nYRSgvdOBSluByTO7AQYBgmJayqA7mJUOBxwRfg2kG5DgsBhmFSIhCM7CxGBLiIILjRcM7DQoBhmJTwW+z23S6CiwhcRDT3YSHAMExKWPUMcLsIRECQNYGch4UAwzApYdVo3kWsCTgFFgIMw6SElSbgIu2HfQK5DwsBhmFSIpo5yEXEncUcQCI9hh8nor1EtEIZu5WIdhLRUv1nqnLueiLaQERriejUdE2cYZjcwBfFHERsDnIEiWgCTwKYYjF+rxBilP7zNgAQ0TBoDeiH66/5JxG57ZoswzC5R4vPQgi4CG4Xm4OcQFwhIIT4GECinSHOBPC8EKJFCLEZwAYAY1OYH8MwOU6rpSYA3THMQiDXScUncBURLdfNRRX6WG8A25Xn7NDHGIbJQ4JR7D0Ejg5yCskKgYcBDAIwCsAuAPe09Q2IaDoRLSKiRTU1NUlOg2GYbGJ2CvepKAYAFHpcnCfgEDzJvEgIsUceE9GjAN7SH+4E0Fd5ah99zOo9ZgKYCQDV1dV8pzCMAzEv8vdPG41gUKCitEDTBFgVyHmS0gSIqKfy8GwAMnLoDQAXEFEhEQ0AMBjAwtSmyDBMrmLWBDoUelBd1RmAnieQjUkxbSKuJkBEzwE4AUBXItoB4BYAJxDRKGj/4y0AfgEAQoiVRPQigFUA/ACuFEJwayGGyVPMeQBEFHbM5qDcJ64QEEJMsxh+LMbz/wLgL6lMimEYZ2A297hCMgBEAMuA3IczhhmGSRqzOcilagIgFgIOgIUAwzBJYzb3lBWFjAtcO8gZJBUdxDAMA4R8Av93+hEY3qsTupYVGue0ENFszYxJFNYEGIZJGikEOhV7MX5Ql7BzLiIIjg/KeVgIMAyTNFIIeNwUcU7VBBpb/Wj1R5aXYLIPm4MYhkka6RhWHcISIs0xHAgKDLt5NoiAzXecnukpMnFgTYBhmKSRjmGPK3IpcRGwv6EFR/95DgAOF81VWAgwDJM00hzktlhJCFoBuYONvrDxV5fswNrd9ZmYHpMAbA5iGCZpAjHMQS7TULcOhdhb14zrXlwGANhyJ5uGcgHWBBiGSZrYjuHwsb31LRh7+9yMzItJHBYCDMMkTUDEcgxnejZMMrAQYBgmaQxNwMIxTIgtBfbWN6dlTkzbYCHAMEzSGD4Bi5XE7BMwc++c9WmYEdNWWAgwDJM0RnSQlWM4jhSwiihiMg//GxiGSZqYjuE4r7XyIzCZh4UAwzBJE9sxHHuRZyGQG7AQYBgmaQKBGI5hZY23sgyxDMgNWAgwDJM0hiYQwzE8sLIUL10+PuK8J57nmMkILAQYhkmaoFE2wsonoI2VFngwpl8F/nzWiLDzAS4qmhPEFQJE9DgR7SWiFcrY34hoDREtJ6LXiKhcH68ioiYiWqr/PJLGuTMMk2X8Rp5A9LIRLtL8Az85pn+YsGjyBTIyRyY2iWgCTwKYYhqbA2CEEOIoAOsAXK+c2yiEGKX/XG7PNBmGyUWCMRzD0uivOohVWdGsCAF/IIh73luLWlOxOSb9xBUCQoiPAew3jb0nhPDrDz8H0CcNc2MYJsfxB6Kbg+SQKh9UgaAKgY/W1eCBDzbgj2+uTM9EmajY4RO4FMA7yuMBRPQVEX1ERMdHexERTSeiRUS0qKamxoZpMAyTaaRj2FoIRI6pSWUBpQGx7DVwsIk1gUyTkhAgohsB+AE8qw/tAtBPCDEawHUA/ktEHa1eK4SYKYSoFkJUV1ZWpjINhmGyRGzHcPhvINwcFFS6zHg92lLkY29xxklaCBDRTwGcAeDHQmj/TSFEixDiW/14MYCNAIbYME+GYXIQfwwhIMtGqCYgMvwE4ZqAdCxL8xKTOZISAkQ0BcDvAXxfCNGojFcSkVs/HghgMIBNdkyUYZjcQ+7mrWoHWSGfVuRxQ13vpTBZsOlbW+fHxCeRENHnACwAcDgR7SCiywA8CKADgDmmUNAJAJYT0VIALwO4XAix3+p9GYZxPoFYmoDc9Stj8nlFXpdhSgIAnz9kBpq7ek8aZspEI257SSHENIvhx6I89xUAr6Q6KYZhnEEsIWClHMjFvkORN8wnoPoCLntqEZbefArKSwoAaOGjf3jla1xxwkAc1q2DndNnwBnDDMOkQGxNQPutCoNfTxoMAOjesTDMJ+ALhvsCWhWhsHpXPV5ZsgPXvLDUplkzKiwEGIZJmpiOYQtV4BcTB2HT7VPhdbvCNQF/eFSQT3EYyLcJcuBQWmAhwDBM0gRjNJWRmNtMulwEt4vCNAG/aYVv1YXC9v2NOOOB+frrbJkyY4I/VoZhkiahZDEL+eAiQos/aAiRVlNoqBQCp933SeT7MbbCQoBhmKQJBIVRIM5MrDXb7SKs/KYOVz23BICVOUh7/J2qitD72TBfJhIWAgzDJE0gKCy1AMA6RNR87u2vdwOINAe16EKha1mhMRavUxmTHCwEGCZF1u2px5R/fIzadlb35k9vrcLTC7ZGFQKxNYHwxz6TOUhqAh7lidyDJj2wEGCYFLnv/fVYs7sen6xvX4UQH5u/GYda/FGdwmqJiIhzJv2g1W/tGPYqDeyDXFEiLbAQYJhUkSGM7XSRckXTBIzfkecDSnjo1m8b8PSCLWHnpSagJpEVeXm5SgdxM4YZhomNtG/rdRSxbk89Glr8GN2vItbL8oZovYJdMTQBtWTExL99GHFeagLNvpAQ2HmwKYVZMtFgIcAwKSLXQLm5nXzvxwCALXeenqUZZZbojuHor1ETxayQGcOqmWj7fhYC6YD1K4ZJEbnWmRc2EWehczJ+xUyj7tZVQhpS5Ll4FaPl4t/i5zThdMNCgGFSJNpit6u2GQ0t/rA2ivlCs7I4H2rxWz5HaggCkSt+PAHZGghi36EWNPnC3zvYXh0vaYTNQQyTIjIKxqwJEAHDb5mN/l1K8NHvTszG1NJGU2t8webRI3usav4E4izm+w+1ovrP70eM+4JBFLrciU2SSQjWBBgmRcjkE5D4/NrA1m8bkW+o2s2wnpYdZOHRi/0ELHb9VkLgyN6djON75qyzfE/uPGY/LAQYJkWkA9RnLoJm0S93xC2zcf2ryzMxrbTy1vJdxnG0wm5SE7Ay/VhZg9ScgGi8zw1nbIeFAMOkiPQJmBOerJqmH2rx47mF2zMyr3Ty13fXGMfRksXkom5l+bHSDhIpC3H180sTmyCTMCwEGCZF5NqViBDIF/74/eHGcbTF2xOj9rNViGii0VTLth9M6HlMYrAQYJgUkYtgiz8YZutWhcKby77Jq8gW1ScQLU/AY0QHRZLKZ3GwndVoSjcJCQEiepyI9hLRCmWsMxHNIaL1+u8KfZyI6H4i2kBEy4loTLomzzC5gNzA+gNBNCmLY6MSQfOr577Cx3lUW0jNDYiWFCaLv1nt8P0WQqDQo0X99OhYFPNve7mSnK0kqgk8CWCKaWwGgLlCiMEA5uqPAeA0AIP1n+kAHk59mkwuc//c9fhi07fZnkbWkIlTvqBAY2sorr2+OTzGfW9dS0bnlU6a/SEBF63ZS8gxHHnOLAPGDeiMycO7AwCG9ozdTL6QawjZSkKfphDiYwD7TcNnAnhKP34KwFnK+NNC43MA5UTU04a5MjnK3+esww9nfp7taWQNuav1B4Jh8fOrdtWGPU9dOJ2Oag6KKgRiJIuZzUFXTxoMr645eM11pgE8dnG1ccxZxPaSikjtLoSQcWK7AXTXj3sDUMMfduhjYRDRdCJaRESLamryR03Od3yBIKpmzMJdSnRIeydU8VKEmYAOmTQBs2bgZJ74dItxHK+pjFWymNkx7PW4jOebC9KN7FuOQZVlxuMXv3R+dFUuYYteJTSjX5s8PUKImUKIaiFEdWVlpR3TYDLAL55ZDAD454cbszyT3EEKAX8wGCYEzF+IfBICKsk0/DIni3ndLsO3oL7fVzedgteu+C6qupbi2Z+NAwA0JJCtzCROKkJgjzTz6L/36uM7AfRVntdHH2PygDpTZEY+Rbwkw4WPfYHZK7UEJn9AhJmDzKUV9jfkj09AJV5nMas7pMlUT8nrJqUdZej9KkoLjH4Fo/qWAwCq+7ePEt2ZIhUh8AaAi/XjiwG8roxfpEcJHQOgVjEbMQ5nwhBNaxvaQ3PeWSX9tCc+Wb/POPYFBOqaQ0LSvNDtO9SasXmlmwKP2vbRWggU6Lb9w7qVRZw77rCuYY+9bpchNKJpFvJvmvMxmNRIqIAcET0H4AQAXYloB4BbANwJ4EUiugzAVgDn609/G8BUABsANAK4xOY5M1lEfgG76WF8XMslhD8YxC+fXWI8NlcP3XcoPzQBIUTYQhxNCAyqLMMt3xuGKSN6RJz7y9lH4rjBXY0MYE0IyCY00R3NRNblOJjkSUgICCGmRTk1yeK5AsCVqUwq2wgh8MaybzBlRA8jdpkBFm89gKf0NoAt+gLnV7x+QoiEUv/zFbNAbDSZg5bvCI8WcirmRTha2L7LRbjk2AGW5wo8LlR1KTUea+ag2O9HRChwu1gTsBkOuLXgk/X7cPXzS3HXu2uzPZWc4pyHPzOcm19s3o/N+xrCHHz5UBMnFcxlIszmIInTe+WaF+FomkA8PErBuAIlLDTWuxV4XBwiajPOvhvTQDAojC9vPpYAbgub9zXErNNy4t0fhmV+vr60ffj/dxxoxG9eXBaWGAZEZsFGq7nvjVFTxwmYhUA0x3A8VM3J63YZSWWxtMlCj4vNQTbj7LvRBjbvazCcebtrmzHwhrfxxrJvAOR3AbBEOPHuD3HmQ5/iYGN0h6aqCew40D56wD74wQa8smQH3l+9N2zcFwhi7IDO6FJaACDSJyBxujNd7sQLdUdtshbAipIC49jjJiOKKNb7sTnIftq9EDjx7g9xzj8/AwBs2ncIADBLr5Xe3oWAJJZGpO5+h/Wybi6Sb0iTmHmt8gcEgkGBId21yKlo5qB4TdZzHbkIFxdo/rJkNYF+XUqMY6/bZXwuBMLMC4/G61ceG/Gab2qbsfKbuqT+HmMNt5cEsH6vtvhLH6fbRQgEBe84dGpjVG1UG44P6R4ZCpiPyB3+459uDhv3B4No9gfQsdgLt4siHMMSp6dWyPuhvNiLg42+pH0CKl63y0goIAImD4+MKJKs3sVCwE7atSZgrm54QDd7yFvaFwiittGHOavadzejWI44VRNw+uKWKN06FgKIvF5fQKCuyY8irwseF0U1ByVaNz9XkddVVqTtIe0QAi4K1Rhqv/Fl2aFdCwHz4nbz6yvCHrcGBG7839f4+dOLsGVfQyanllVa/UH876uQk7clRuEz1SfQXrKHfbpDs09Fcdh4qz+Ibfsb8fbXu1Fa6DGeZ8bpH5P83hR7NXOQHZWdiUhxDKf+fkzisBBQONCoqbnSNimEwGZ98c/Xui9WPPDBelzzwlLjcYsvhiagLHRWzcPzhWZfwBBy9Xoggdlhvr8h9Li8xGscv3HVsTiqT6iJeiAosGTbgXRON60YQqBA0wSS9QmYkXdPLM1i8rDuRrY6Yw/tXAjEttkKEapoaG4ins+YQ/DW7a2PussPtANzUFNrAENveheX/2cx7p691rCJf7ohvIfC7rpmAMB9F4zCppqQ5ji8V6eIhe0H//wMu2qdGU1lOIa9MjrIHiFgOIZjvJ301zkVIbSeE9v35074ebt2DEdz/HYo9KC+xY+gEEZ3pFi74XyjyJQl/a+PNqFvRYnlczfU1BvHTo96icbW/dqC/t6qPXgvAf9Qx2Jv2GO3KxT+2K1DIfbWa+UjXl2yE1eeeJitc80EcvNUUiB9Ava8b+j2if6Gbhc5OsT2f0t34toXlgEAltx0CjqXFsR5Rfpp55pA+MJ+zMDOALTa5oCmnkpVt8nXfsxBVo7LBRutO4fJGxrIX3NQtCifaJQVWuyt9M9UPfeIQ8txy81Tke4TsOu/nkiegNM1gWcWbDWOY+XfZJJ2rQmYd/fy5paZnkIIePXU9rYuBE7Gaqc16+v4hWCf+Xwrjj2sC6aMyK9GctEyf6NhJQTkulVSGNKyKnJgF5gMcvNUUpB6Xa0Xph+jhGhrH5I7hhRwk7OFgDr1XLmOdq4JhH+5pS1ctgHUfALaR9SehEC8yqC9y4tx0tBulucu/88Sy3EnE+9/f98Fo/CD0aHmeVZCQIY/lhaEzp1f3cemGWaWVlN0UCqMG9gFPzmmP4CQOTGWo9ntIkdHoald05btqMWlT34ZNZQ4U+SlELjhta9RNWNW3OeZzUE+v4wK0h4HhTD+aY0t7cMc1OIPGA7OaHTrWIhfneQ8W3aymGsEAcBfzzkSV544CO9fNwFnjuod5gew1AT0W61UOefUiqty81RsgyagItf2eOYgc40mJ6EKuN++tAwfrNkbsz5XJshLIfDfL7YBABriLNyqEKhr9kWUiQiKUKXDxixL60xxzO1z8frSb2I+x01kbffWqZoxCxt0FT8fsDIHHdatDL87dSgO66aFK6pNVkotzUEi4tzfZq/Fuyuc12+p1R8EUah2kF1+WrnDjxUi6nKRowMQvO7IJTfbVoa8FAKSZl8Aa3bXoWrGLMxbszfifIuysH97qDUiNFJAGDdkW+3CTkXmSsTC5SLLhU7l9Ps/sWtKWcfqS+oxVQJV1XxVIEjkwlVoOvfHN1chEBS47Mkv8fkma+d7rtHiD6JQaQxvF/IzihVt5HG4Y1jVBOThoSxbGfJaCLT4g3jy0y0AgEue/BLPfrEV763cbZxXF/1WfzBCcwgGgbm68GgvQsDMM5eNjRhzEdCrvNji2SHyqea7VSE4847OY7HDU/nDlKHoWlaIgZWlYeO7apuxv6EVc9fsxQUzP099shmgxR9EgdulLGj2LMpdy7RyHD07Rb+3XBQyBz00bwPueHs1Vux0TrMedbMgZVm2a5TldXTQ7rpm9FYWqxtf08pCbLp9KlwuCosOuuSJhRG74AONrcY/qL3WMB/aI7IyqF0Zok7ByrTldYd/Bl79MznvaM3Ze/zgrmH9hycd0R2L/q87nvpsS8R7+R2WiNjiD6LQ6zYawNvFD8b0RnGBG6fGKB6nOob/Nltr+vSvjzfhkZ8cbdnGMtew+syyvbbktSbwg39+hnvmrIsYl4Xi1N3qN7WRzlDVDJCvyWJrd9fDHwii2RewNEeoXbAmD+sOAOhQ6I14nhX54hd47avIZjnmnf8nG7QFX6r2f/z+cMv3slo3zfdWfbMPlz+zGDsP5mZGcathDtIe22WiJyJMPbJnzE2GR3cMn/C3eWHjsgx8ruOxuDbHRgcR0eFEtFT5qSOia4joViLaqYxPtXPC8UikQqMvILB2dz3+9NaqiHODTOq65M3lsZ2lTmTrtw049R8f48+zVmPoTe9GmCN+NK4fygo9OKybViJ64uGV+P2Uw/GXs0cA0DSqWJgL8jkN87302i+/axybNYGFm/cDAL7WTRNWDkDAeidoNp29vHgH3l25Gz96NDfNQy3+AAo8LlAW6n1Kx/AWU4+LbMwlGazcKKrGmA2SFgJCiLVCiFFCiFEAjgbQCOA1/fS98pwQ4m0b5pkw0So3qrT6g7jiP4stbb3RZEi2PfjpQBY8e2t5ZITKiN4dcfvZR4KIjKipskIPfnnCYeii227jmQPk85zIza+vwIDr3w6rHqvaqs2L/J/O1Hb+A7pqm4hou1krZ6osSCf545va5iRXtU/NMWxveGiiRHMMOyXa1mp9+sAiaCWT2GUOmgRgoxBia9xnpoHrXliK++euBxC9m5NKayBoGcEBxK5/4/Q68GbkQmZVSE9drGTyWElBdBfSD8aEkqUevagaADC6bzkemrcBlz+z2Jb5ZpKn9fT+j9fXGGPqPWNW6wdWatqSXPw97mhCIHJs3yHr8gG56nqZs2oPVu+qMxbeTH4tXESOLlTot7D/n3FUdjPs7RICFwB4Tnl8FREtJ6LHiajC6gVENJ2IFhHRopqaGqunJMyrX+3E33XbfyJRPK3+YNSd2klDu0d9Xb41npcCz6pMtvrpSMdVaWH03d91pwzBaSN64OtbJ2PikEoAWp7G32avxbsrdztWgN78+krjWDUBeU2biNH9yjF5WHf83+nDAESGkEqsEsT2HWoJezxtbF8AwOFRSiYHgiLCjlzb5HNsVdK2EO17m6PyMgKrRLdYXdQyQcpCgIgKAHwfwEv60MMABgEYBWAXgHusXieEmCmEqBZCVFdWVqY6DYNEYm59gSAORomHv8oiE1buAJ1cvdCKmGGcYZqALgQsNIGxVVrRvT4VJXj4J0ejQ5EXXjfB7SKj/AagmdN21TY5OuVf1QS8pkW+pMCDmRdVG/4T+el1LAr/zKzq4pgLiUlB0RBlQ3PLGysw7OZ3w8ZO+ftHGH/HB/EvIkUen6+11Dz9qJ7GNQrbSsjFJ5oQcEo/cPM8+3cpwfdH9srSbDTs0AROA7BECLEHAIQQe4QQASFEEMCjACIDzdPI+j31Uc/ddc5RALSdbbTIC6vSrvdfMApA9r34dhMrPln9qklzkJUm8MQl38G8354Q/loiFHvdaGoNvf+qXXUYf8cHeGjehpTmnC3++eMxKFD8AGbHsJlOxV6cX90Hz1w2LmzcSkFQQ5Pvnr0WPv3/cqDB2kz0n8+3RZhEZHnqdHObHkxR7HVnxQ4fTQgkYgbOBcx1uayihTKNHUJgGhRTEBGpBq6zAWQ0REQ61aaN7Rdxrn8XrSa+z7T4Lbtlcsz3lLbwfEsYiykElHtTqrBWWcKlhR7DGapS5HWHaQI7DmimtPdXO7Nfc5+K4jBTTrxcCZeLcNe5IzGyb3n4uMXK+dj8UMP6B+dtMD5v88K2Ymdt2OYl05mzqu9IDR3OJNEqjDolcMMXFJgwpNIoOBgtiiyTpDQDIioFcAqAV5Xhu4joayJaDuBEANem8jfayk+PrQIAXHniIADArycNNs5JO+6PH/si7DUd4pRAkCVzN9U04KVF2+2aataJ1Ts4zDEclKWDE88tLC5woVn5YsrifE7FbONPtvhbIq8zqtmaooPOeGA+jr0zZPKxEuLp9L2o7TOzleUaVRNwihDwB+F1kWFazAUhkFLGsBCiAUAX09iFKc3IJrqUFmLzHVocu4wckuq8+XsSL9RRVkv8/SvLAWj20LYsiLnKuj3RE2zUj+TH4/rjyc+2xBWWKsVed9hO9mCTtoDEK6+Qq0SL9mkrsW61M0f1wrw1e7FL3+23xDFxtPgDEZU8W/xBo9mL3XyrRDGpwQSZdJVFEwLRfHy5hj8YhMcdEgJ23Vep4MxvpIKqEtc2+tDY4geRpq4SUdjOK1pYqBmpwv9i4kBMnzAQHYvCM2RzNX67rfzdIptaoibf3HzGMKz505Q2lQkwCwFp93ZqyQm7bLexGqZUlBSgrtmPJdsOAkCYOc0Kq914Ov1WahSTENlJ0ErWJzBr+a6cyMD2BwS8bpexITUHGGQDx29n1S/C0h0HsXFfg3aDWnzZCmLsQl++fDwqO2jJTa9e8V0EhTBUNbODLp+Ko6nI3spAuIPc5SIUudq2uyzyusNUdJlR60wRYJ/art6XvzllSFhZk0KTnd0XEGj1azktVvZ/q/uwyRdAObSILru1rmhJTZk09EUTAmt31+NgYyvKSyIDO4JBgSv/uwRdSguw+KZTAGgBJE8t2IJbvzc8o9qpLxjUhIA0B3my/43IvhhKEVUIuEiT+Gbe/vXxeOrSsRGx3WP6leOly8cDAKqrOqN/l1C2p/qlN2sQsWzpucrCzfuxeled8Xj7/sicB+n4HdW3HHeec2RKf6+4wB22K5VdqMxN2HMV82JjtznI7SIcMyjMkooiiyzcf8/fBMB6pyuFQK1iCmlsDWD7/kYcduM7+J9FzaNUUPtM964ozopEj6ZJ7a5rxun3z7c8Jz+nb5XN3B3vrMF/Pt+GzUpGeCbwB7RGVXJNsbscdzI4Xwgocbe1TdZ2wWG9OmLikMqIsL4/n3UkvqPHucfCLATMDjsncP6/FuC0+0I1/mcrJbUlcid69cmDLXdUbaHQ40KdYjduUVp2OgHzYhMt+autyC89IVy7GNazY4QmAACNLdrnZtXdTG6AHvs0FF3U1BrA8h1a/aLXl9orBCYP1xIp7z5vJH47+XBb3ztRVOH8xE+/E3YumrnHatMmo9Uy3aXMFxDwKJpALpA7M0kSVQjs02Olxw2wXtgL3eE7rR6dihL6G2Z7sBM1AZXdtc1hn9vsaybgwR+NNha+QhvU49kr94Ttsg7pi5laNrnFH8C6GHkd2cScGGibT0B5H3VT8vbVx1v27O1dodUramiJvOfk/1AGPgDhPgG7HcS+gECR14Vzj+5je2vJRFE/P5mYp7Jmd13EmNWmTQrjTJt2/cEgvG4yTNO50CXN+UJA+Scu1ys4njLMuvSDan9bctMplolhVpj9C073CRxzx1zc9e5a4/HhPTrgjKN6GY5fqx1pqsiGPY2tAeOLetV/v8Lkez/OuSS8Vn8wwgZv185NvZXMXcY6FEWayuTnduo/Po44Z+UYbvIF0rawtPqDlr6RjNYOUoSAlZCbel9kRzur+ytbHQM1c5DLML1mu6EMkGdC4NUlmvob7QurOoYTFQBWODk6yOwLuOe8kcax3O0WuO3f5UlzxsLN+zHlH59gw956fKrX4I9mxssWVqVH7HIMG+YgijQxlVv4S+RcrBYLK410f0Nr2oSqLxCMGVyRCVSNzCqDXZXdTa0BVM2YFRYFJ0ugSI2iyZfZ1o6tAU0TkBGHuZDpnFdCQGLeYUnsCk/MtZ1rPNRSDcffFd6MQ63+qS5QqfLEJeH2WvPCure+xdjJ5ZwQsCioJ003j11cjYd+NCbp9w75BCjifqwoDRcCxV43Glr8UZ2XNfUtuPjxhQCAI3pqHeCufn4pntBbqtrtc/QFwjUBqS1lsvSB6kgtKfDgzauOi/rcy576EgDwxrJQL5Bmfb2QU1ZLm6QDn1KiJhgUhjbVoSh3qhA4XwhYFI6KVus82SxPM7e8sRJTLNTzXEQIYbThs0L9TLp31PsE2PA5dTY5ls12WReRsXhku9G2mRmvLo8Yk5/TpCO64/QUSv+q62Uf3d4va1qVmTq2FRe48egnm3Hi3R9avtfrS7/BR+u0Crxq5Ncq/ViaaYQQePCD9RHVStuKLyDCTKrHHdYVAPBDveppJpCCU/4+sk+nsPPqBvAzJZpJIjeN0qxk5XC3k39/shnH3vkB9tQ1GxpJsy9gRMnlghDIqzwBSVkbMluTwRyF4A8E0eIPWtbWyTZtiX64/QdH4vWl3+CIntYljNtCSRzHYZMvYAiBXPgiqMjF4+Lx/TGoWxmqulh3m0sG1aZNRNhy5+nGY/UzO/foPnh58Y6w1/5hylD89d01xuNP1scuwS537at21eHu99ZhwaZv8ezPjkl67g0t/rBKsn07l4TNPxNIRUR1qh/WrcxoZRpvA2MIAf156dbqP1yr5Vas3V2PB3WNvK7ZZ2ySrNraZpq81ATKiuxfjGNpvIfd+A6G3zI74wW9EqEtJXZ7dirG5RMH2aIxxYtMueSJL40vgFr8a9GW/bjznTWWzTcyzU+PHYCLxldhwhD7Sp0bi5TFR9y3cwm6dSjEjVOPwJ0/iMzTMPu64t1ucoGTf3P7/tQyZhta/Vnf6MhrUTNt//vzccr52K+XQkBGwqW78FxXPQF1d11osW/1B9FN17pzIE0gD4SA/k+97LgBxlgsTeDyiYPwyE/abtO1WhjNtfEPNFqX/s0msQq3nXd0n7T93bZE06gq+bmPLMAjH20Ms+Nmiyq96qyduKLLAADAwhtPxs8nDITH7ULfzsVh52J9pledGNkHo9kfhBDCSKDctr8Rb6bwuR5qCWRdCFh1buvWIRTqHVcT0DcX8mlzV+9FMCgiejrYjWqx6FTsRZHXjbm/mYjlcSoYZwLHCwG50z2vOrSgxRICM04biikj2m7Ttbq1zLVdajJU070tNMSweaYjFFTSlmgauRtTo12yGYZbVujBpccOsM2HpNKW97z25CFhjwvdLgzTHcBmzrEQ6I0tfjz/5XbDDAEAv3ruK9Q1J+eIP9TsQ1mM7nKZQO7go5V6UPM7xg/sEnFeLsbSTLpwy34cftM7GHXbnKj9G1JBVnVVhcDvpwwFAAyqLLMMC840jhcC8sNVQ9fSYQ6y+u42tgbCSvc25JiDEwCWbDsQ9Vw6m4XHa7qiIoWAmhCVTdNaky+A4oL0fDWMnWwCETXm+PsCjwvPTT8G7183MeK5Vp/3oq0HcP2rX0eMb0uyTWpDS8Cyu1wmcRlhzOH/n4GVmt9G9YFZFeB7dckO/P7lZYYfauKQSqP5+8E0RKnJ3EgZ/DC8V8esa1Nm8kcIKKpyOhzDVhUTm1oDxg0E5GYS2VX//QqAVg/ITLRQWjtoizmoqVUmkoWE6DdZqvjoC2iJYlZ1fOxArR0UjypTs54Cjwudir0YaBqfPmEgepcX44fViUXpzF65G19u2Z/YhBUaWvxp2WC1BStzEABco2tNrf6gESllFXDw7/mb8eKiHdim58uoG7d0JG7JxL2dB7T7+SfH9Lf9b6SK44VASyBSCKRzcVNpbA2EJXvkWjmJeWtDVR+tPpN0lnVuS4lc2UtX/dJmK3dA/j/TVRbBcGwmYC47un9F2GO5+zWX9L5h6hEgIvz13KMScmI/8MEGnPfIArzYhgZJQgg0tPrTHnkXD/n5mTUptU/vP94PhWJGQ+7MtynJk+n4/kofhHQMV5Rk3/xjxvFCoF63bxa63bjyxEHoWORJiy3XKgrpz7NWhTmUrDKJ65p9qJoxCw8o9V0ywfb9jbjkiS+Nx0O6R4Z9plNzaUvvAbn4q5Ea0tez82ATqmbMwrsrIqvDpgNZkbMwTY1Z5K3Zls9Hkoh2dcv3hiX8fr9/OTIfIhpaOQrrFqOZRG5cYglR2WCmyRcIM5P1Li+OeK7amzkd3wcpiGQ+R7oa/qSC44WArIHj9RB+d+pQLL/11Iz97U/W7wsrr2u+iYJBgaNufQ8AwurGZwJzgtilSvSUJFOZz7efHbssdWNrqK6QRKrmK/V6UA9/uDFNswvx/MJtRka1VTE3O4i2k02ERISAOUnPLuTOOdtCQH5qVkJg0tBuAIAvNu/HrtomNLUG0EkpxRHv80vH98GcJJlOP1yyOF4IyPTrdH1p4zFDcbztO9SCv8xahWZfAM8v3IaBN7ydlTkBQL/O4eGNA7qW4oPfhDsUMyUEvjuoC24+YximRcksbTAcwyH7rPS1yJ1TJnZQN72+wjhOVyN1c8ZrW7BaxN67dkLY43Qt0tJpn+3oIOn4tervcM/5oTpYv31pGeqa/WFCIF5hvZcW7cDXehluuzB/x9IZkZcsKc+IiLbojeWXEtEifawzEc0hovX674p475Msw3t1xNiqzmkxAbWVe95bh0c/2YxXluww6reYmbd2L5ZuP5j2uXxrEe42sDK89G6mKhgWel249LgBOLq/dYnvPXrSmMyzKCv0hBqmNGWuLaXq5E+fJqD9TlQTWHVbSLO1ssebF/0CjwvHD+6a0Hu7XWREtz368SY8qfQlMCPrKZlLW2QamURo5XNS/TifbtA09I01obpL8YTAG8u+wfcetG5MkyxrdoeXSo+XSZ8N7BJLJwohRgkhqvXHMwDMFUIMBjBXf5wWapv8GelW9d61Ws39WEinYiAoLNvGCSFwyRNf4qyHPk3LHFWeW7jNOFaLxEk6lxbgZ8cPTPs8gFCJ5GhZwIu2HoAQAr/TbdSdir2GT0B+pplu/pEuzUOuQ4m2NCxRQjKtBFOpxaLyzGXjUK07lc0CYeqRPXBUn06YNrYfAkFhmCv+8vZq3PrmqqjzeE3vUqZmvmYDKaitNAErwXD6kaGcoGCGg/eEhdAp8eZWeCiQPnPQmQCe0o+fAnBWmv4ODrX4DJNQOhnSXau5Lzm/Onq27acb9lm2wctWnRCzaQjQ+imM6N3J4tn28aczh+O+C0YZO1hzoxaVXcpn06nYiyafloOxUa8J05byF8kytEfIeZ6uvyeFWayG89GQBedUopl/5N+55uTBYeNdywrxxlXHYZheHyrR4n29yrWs3NEWocaZRC7+XcsKI85ZOdsHVYbCaWMlTqYDqc2qzumiNOWfpIIdMxIA3iOixUQ0XR/rLoSQ4Ry7AUR0eSGi6US0iIgW1dTELoQVi+37m7KiYt14evQojNkr94Q5iUf01rI8k03SSYaThnZDVZcSTBvbN6ykxmMXV0dkoqaLC8dX4cxRIS1koh6++NLl49FT7+omk3xueC3kW+lU7MXCzfsx6rY5+NfHWo/d2kZfRvvBpitZTb5vMtFBqsnzT2eNwMXj+0eNkpGmD7fLhfsuGGWMSw1HCo9YQuCheRvw7gqtDak0tVR2iFx8M8m4AZ1x8xnD8OezRyT0/L7KBuhgY3jYcWWHQpQWuPH59ZNsnaNERr1de0ro+1aS5WQ7K+yY0XFCiJ1E1A3AHCJao54UQggiivhGCSFmApgJANXV1Ul946RNOxvJparj8OQjuuGT9fvCFv4x/SsMe+Ckod2xYmcd9tZnThNo8QfQpawQd/zgqLDxSUd0x6QjrDuvpZs+FZFVJ0f06oRNNQ34cG1oIyCbhai5Apv2NeDEuz9Ma9XKFn8QE4ZUYlSfTjjh8G5p+RtyNx/NSZ4oF8ZJOhrZpxzLd9SivNiLUaN6Y8PeQ3jggw0o0p3LUgiYs9x3HmxC7/LisBLk/76oGv/5XDMvZjvEkYgsI92iYaUFS04YUom/nTcyzGxjZ46RNGVWKBFb2QpgiUXKQkAIsVP/vZeIXgMwFsAeIuophNhFRD0B7I35JkkiHYnDe1nXU0kHH/xmIoJChKWtz7ywOiISKKA4Gcv1BJF01CaJhs8vst4FKhbye9dN31mWl3iNnZqVqp8Jmn0BdOtQiOvS2ES9vKQAm26fmpQm0BZuPP0InD2md0TWsVu3m5cpmoBaCPHYOz/Ai78YH1a87mdPLzKOc3ERi4XM76nqUoLnp4/H3vpmdC4twDXPLzV26KqG1eIPotUftKWdqBQCqqUiEwEObSUlIUBEpQBcQoh6/XgygNsAvAHgYgB36r9fT3WiVnx7SFtUu6TQKrKtmCNsAGvVXnWgSSGg1iZp9gXSuqtqDQTRsSD3shMlAtrCI0vqdi4pMIRArKilG1/7Gn+Jk3eQLNr/JP2CM90CANB27GP6hYLypI9A/mmpCTS2+tFoCmNc9U1tVJ9IW2pC5QLV/TvjixsmobTQg7JCD3roZsiXr/hu1Nc0tQbsEQK6OSjb2lM8Ur3S7gDmE9EyAAsBzBJCvAtt8T+FiNYDOFl/bDsdijz46XerMLh75MKcLX51klbSV2YIAjCakvzj/VDW8C2vr0zrPFr9QRTk8BdWagLdO2pfyh1KraBYsdTPfrEt6rlUOdDoi+j7mwvcduZw/O7U1LSTmbpvZZPuV5FRRQ0tgQiTkNtFUSvi5kIodqJceeIgFBe40b1jUdxyF09dOha/mKhFy322cZ8tf99KE8hFUrrjhRCbhBAj9Z/hQoi/6OPfCiEmCSEGCyFOFkK0vVpVAvTtXIJbvz8ch3VLvROWXYwfFF6+9h8/HBVmE5SoMc2fb/oW/9ND8OzC3A8215AGCOlolLv/N686DqcMS8xnYRWClyzS/zBn1R7b3tMuLhpfhSst+gW0hSsmDgIAXPAdzRdRomgCZiEQFJnLIbGbc5WS2m1xwk4cUmmU6b7i2SW2zEVqArluQss9V7VD6V1ejEHdytDBlExz1uje2G0RGqoKhgtmfm481y58AXvsmulCrt+Viv1/bFVnHNmnE/yB2EJ9xc5a3PHOany64VvM++0JGGCyeyeDXAhzscqjHfxm8hD8etJg454I1wTCzUHPLdyW9fIQyXL3eSPx6YZ92FXb3GYnr90+NKkJFHndmHnh0TnpDwDyoGxENvnt5CH46zmaffrTGSfh6UvHWpbaVXcCV5ygFbnb35DeBjSt/tzWBCTSVgsAFaWaAPW4XUanLCJgiMncd8YD842M0G8ONmFPXTOuef6rlHavMr1fhq7mG0QUtimQu+Tb3lqFTfu0XAwZSrpmdz0Wb43ehyLXkRuMthYBtDvIUGoCJQVuTB7eI2tRefHI/VUih7nqpMH44Xf6hY2ptsfLdRW8VKm3MnFIJbqUFVqWdbCT1oDIaSEwul85AE0IyPounRUHv3TQjq3qbIT5WXXVamwNYNztc/G/pd/gvVW72zyPZxZswXsrdxs281x34tmFKhDeW6mZwPrGCKd0EjIoo62aQKyNui8QRNWMWfjXR4kXMkx3WXK7yN1VwqGo2cvyJlRLBIyt6ozOpQV4f/WetCaP+QLBjPVVSIZ7zh+JV3/5XXQq9hplP8oVE5mstiigaU9H9OyI71RFlqCqV1olJmPCuOn1lZj+zGI8/6VWWz8T0UG5xqyvtbzOjkWeiJpG1582NBtTsoW23v+j+obur2XbD2KR3nhn5Te1hs+oLdWAneITaH93fJpRd5JWu0qXi1BRUoBmXxAT/jYvbfPQHMO5aYMEgI5FXiOEUc6zXKkBJXNADjX7cXT/znjn6uMtP8/65pBTc8WO2jZ1zLKqoprrX9h0UlLgidAeLxpfhaP7V+D604ZGVCzNddqqCffoVIRfnXQYiIAzH/oU5z6yAOv21OP0++fjz29pdZVilRP5aF2NEVX14qLtuE1/Ta5rl870/uQ4HhfBHxRhO5FHL6o2CqhFy2sQQtgWgucUnwAQqqipFgKURedqDoV8J1aLdn2zD52Kvaht8mm7tDlIOKu40aL9oFMdosnw/nUTcfLfPzIelxZ4UOBxhXXLKy5w45UYMfW5yPdG9sKby75JykdUVugJ6+08+d6PAQDzdR+UVUDaV9sO4Ox/fgYAOKxbGd6/bmJYw55c1sgB1gTSgoxWUXcApwzrjtP0ioaqyUHtmKWWMk6FYFDAH8xtn4CKXHhVU5qsfql+gcwNOoBwTaCtWAmVigwmHmYbtbgaoH3+TrlnYiHvmWTaRUbbBDQpxefqmn2oU8yQsr4SAGzQCx5OVNp85npuhfP/4zmIXMqj2ZfVaqKX/ycUk+y3qdZtq0Xf5VxGhs6pzd076pqAWsjt+CHhZZG7lhWgrtkfUSc+0R2gWQg8elG1ZQvCfEVdnKZPGAiXi2I6R52CLEooExHbQrSKxKq/6qhb38OY2+YYj612+k4yK7Yf3TeDyN1AtF3Vqm/qLMd9fgHYsBGVdstcrh2kMmloN3y4tgb9u4SiUzqXaR/EOWNCyT9nHNULJQVuXPqkVsumQ5EX9c2+CLNOfbMPXRKoP9RkEgITE2jSnm9ce/IQNLb6MUN3AMdrvOIEfjFhEAZ364AJg9v+/4yWYLZTyWgHQmU43l2xC/d/sCHi+Vb9DnIVFgJpZH+UMNDnfn6MpVN4ybYDuOTJL1NOgJLOUadoAtPG9sOkI7qjl7ILLyv0YNktk9HRtDPr0TH0nA5FHuytb4ko+1zf7E9ICJjNS075vOzkalO/gXSV0M4kbhclnHVupq0lHp76bGvE2LsrdhmRQU6g/d31GWD2NRNQUuDGuIHW7RT7dSnBFScMihi/5MkvAQAn3v1hSn9f7pSdsqh53K4wASDpVOyNsKeq6nrHIq/RiF4lET/BR+tqcM7DnyUx2/wm0x3cco22RvJYmfsv/8+SMJ9BruOMVcJhHN6jA1bdNgVDe0QvcW3VFvCEwzX11a7GHfng5DMjfQUA0KWswGhSr5LIF/Cud9fEfU57RNUEzhrVK8Yz8xOzJjC8l3V+CgA8vWALNtYcsjxX3+zHkO5l+OT3J9o+R7vJv1XCIVjZHhdv0VL11TaHbUV1ijpFE2gLava1WndI/fKqCWTXvrAU1724FAcbW1E1Yxbmr9+HxlY/Vkbxy7R35Mb2hqlDcev3h2d1LtnA7ND91UmH4VCLtWnn5tdXYk+ddfmXfYdacWTvckdkYeffKuEQ5GJWUeI1ukTV60XMZMLJws37sW5PfZveV20X6M2HUA8TMvu6Q5En7As2sk+5cVynmINe+2onXl2y0+hc9pPHvsAxt8+NeN/2FBUUC/n5jupbERYR014o0b+XXcsKsfj/TsaUET2xRS+/3b1j4hr6vkMt6FjsDJcrC4EsITWBitICnDaiR9i5vboQOP9fC4xklUTwBYIY86dQ6Fq+2nefvnQs3rn6+LAv5d9/OBJn61VYf//ycvz7k01hpabV/sR1Fj4DNVGtPSNNiLleAz9ddC0txPnVffD4T6uN4ALZ+Oii8VVtei/VdJnLsBDIElITKHC7wqoddutQiP0NrUlFF/zhleVhj1scWhM+HhOGVKJPRQkqO4TiwHt2KsY95400Hv951mpDswKA++auRyzaY3ioFbIRUXsVAi4X4a5zR+IoRbOU+rRMrhvZp5Pla689eUjY42g5B7kGC4EsUezVbpACjyss2eTH4zTT0IPzQovWoij1cB6fvxmfrA91MDMnScWqc5IPdDM50F0uCvuC3vH26oTeZ9avj0u5c1e+8D3dGdweTUHRuPl7w9C9YyEmDKnES5ePx1UnDbZ8ntn62skh2iULgSwhs2S9bldYZrFs8P3QvFDJ2nMfWYCqGbMiuo/d9tYqXPjYQgBaVEefipCNvMDjwtQRPdM2/1zAKorq9atCC/pzC7cn9D7De3XK2YYfmeZ3kw/HgutPCivr3d45aWh3fHHDySgp8OA7VZ2j9pww945uS2ezbOKMWeYxXUoLjLLJAGL2Qr3mhaU4a3RvBIMCzaa6KJPv/QgbazS790M/GoOpR/bI+ZolqRItptucYBaNy44bgLNG2dfNLR/wuF3o2Ymd5LGItsPvYSpTUdU19yODgBSEABH1BfA0tGbzAsBMIcR9RHQrgJ8DkHaKG4QQb6c60Xyjun8Ffjt5CH40rn9YzaB4DbG/3LIf5z2yAHedc5Qx9qe3VhkCAABOPyq/NQCVm88YFvGl3GVq57nx9qkYdIN2C1aUeHGgUQsh/b/Tj8h7QcnYj5WW9MC00ZiqF4gc3a8c8zfss2yClIukogn4AfxGCLGEiDoAWExEMjTlXiHE3alPL39xuciwLTYqFQqt2lOqnPfIAgDAv+dvMsYem785DTN0BpceNyBi7Efj+uGfH4bMaW4X4ZUrxmPdnkOo6lKKaY9+jt7lxSwAmKQwO837dS7B90ZqvpRz9Eb3AyvLIl6XqyTtExBC7BJCLNGP6wGsBsC6dRJI22GX0oKE69mv22OdqThtbF/b5uVU+lSUGD0FZGb20f07Y9rYfobWkOs13pnchYjwi4kD8dPvVgGILEToNGzxCRBRFYDRAL4AcCyAq4joIgCLoGkLEV2riWg6gOkA0K9fP/Ppdse9PxyJqi6l6GAhBCYN7YZuHYvw3MJtcd/HquZ+e8WquYxMCvvZ8QMzPR0mj7j+tCOwYmctnvxsi+OL7qW8HSKiMgCvALhGCFEH4GEAgwCMArALwD1WrxNCzBRCVAshqisrOUb77NF9MLpfRVhTk3N11dIfFAnXcZG7E8aaTiVebLnzdPxoHG88mNQoL9G0ylxu45oIKQkBIvJCEwDPCiFeBQAhxB4hREAIEQTwKICxqU+z/eB1uzDr18fhq5tOwRm6gzcoBMYN7IJVt52Ki8b3xx+mWDf/fvBHozGyb3kGZ8sw7ZfKDoUgAn472dk5JqlEBxGAxwCsFkL8XRnvKYSQPRPPBrAitSm2P4b30hKexg3ogsnDuuP6qUcA0HwHt505AgCwZncdFm89gHt/OAoXzPwcgaCIG1nEMIx9FHrc2PiXqRH5AU4jlVXjWAAXAviaiJbqYzcAmEZEo6CFjW4B8IsU/ka7prjAjZkXVVueu++C0UZj+o5FHhxo9BnN2RmGyQxOFwBACkJACDEfobIaKpwTkCFkiGP3jkU40OgLK63MMAyTCGw/yAP+deHReHXJTqPkBMMwTKKwEMgD+ncpxbWnDIn/RIZhGBOcMcMwDNOOYSHAMAzTjmEhwDAM045hIcAwDNOOYSHAMAzTjmEhwDAM045hIcAwDNOOYSHAMAzTjiEhsl8Lm4hqAGxN4S26Athn03RygXy7HoCvySnwNTkDeU39hRAp1eLPCSGQKkS0SAhhXWnNgeTb9QB8TU6Br8kZ2HlNbA5iGIZpx7AQYBiGacfkixCYme0J2Ey+XQ/A1+QU+JqcgW3XlBc+AYZhGCY58kUTYBiGYZKAhQDDMEw7xtFCgIimENFaItpARDOyPZ9YENHjRLSXiFYoY52JaA4Rrdd/V+jjRET369e1nIjGKK+5WH/+eiK6OBvXos+jLxHNI6JVRLSSiK7Og2sqIqKFRLRMv6Y/6uMDiOgLfe4vEFGBPl6oP96gn69S3ut6fXwtEZ2apUsyICI3EX1FRG/pjx19TUS0hYi+JqKlRLRIH3PsvafPpZyIXiaiNUS0mojGZ+SahBCO/AHgBrARwEAABQCWARiW7XnFmO8EAGMArFDG7gIwQz+eAeCv+vFUAO9A6+F8DIAv9PHOADbpvyv044osXU9PAGP04w4A1gEY5vBrIgBl+rEXwBf6XF8EcIE+/giAK/TjXwJ4RD++AMAL+vEw/X4sBDBAv0/dWb7/rgPwXwBv6Y8dfU0AtgDoahpz7L2nz+cpAD/TjwsAlGfimrJ2U9rwgY0HMFt5fD2A67M9rzhzrkK4EFgLoKd+3BPAWv34XwCmmZ8HYBqAfynjYc/L8rW9DuCUfLkmACUAlgAYBy0z02O+7wDMBjBeP/bozyPzvag+L0vX0gfAXAAnAXhLn6PTr2kLIoWAY+89AJ0AbIYerJPJa3KyOag3gO3K4x36mJPoLoTYpR/vBtBdP452bTl5zbrJYDS0nbOjr0k3mywFsBfAHGg73oNCCL/+FHV+xtz187UAuiDHrgnAPwD8HkBQf9wFzr8mAeA9IlpMRNP1MSffewMA1AB4Qjfb/ZuISpGBa3KyEMgrhCa2HRevS0RlAF4BcI0Qok4958RrEkIEhBCjoO2exwIYmt0ZpQYRnQFgrxBicbbnYjPHCSHGADgNwJVENEE96cB7zwPNXPywEGI0gAZo5h+DdF2Tk4XATgB9lcd99DEnsYeIegKA/nuvPh7t2nLqmonIC00APCuEeFUfdvQ1SYQQBwHMg2YqKScij35KnZ8xd/18JwDfIreu6VgA3yeiLQCeh2YSug/OviYIIXbqv/cCeA2awHbyvbcDwA4hxBf645ehCYW0X5OThcCXAAbrUQ4F0JxYb2R5Tm3lDQDSe38xNLu6HL9IjwA4BkCtrhLOBjCZiCr0KIHJ+ljGISIC8BiA1UKIvyunnHxNlURUrh8XQ/NxrIYmDM7Vn2a+Jnmt5wL4QN+tvQHgAj3SZgCAwQAWZuQiTAghrhdC9BFCVEH7jnwghPgxHHxNRFRKRB3kMbR7ZgUcfO8JIXYD2E5Eh+tDkwCsQiauKVuOHZucKVOhRaVsBHBjtucTZ67PAdgFwAdN6l8GzdY6F8B6AO8D6Kw/lwA8pF/X1wCqlfe5FMAG/eeSLF7PcdBU0+UAluo/Ux1+TUcB+Eq/phUAbtbHB0Jb8DYAeAlAoT5epD/eoJ8fqLzXjfq1rgVwWrbvP31OJyAUHeTYa9Lnvkz/WSm/+06+9/S5jAKwSL///gctuift18RlIxiGYdoxTjYHMQzDMCnCQoBhGKYdw0KAYRimHcNCgGEYph3DQoBhGKYdw0KAYRimHcNCgGEYph3z/zAGhOVAc3aTAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import mean_squared_error\n",
        "#  calculate root mean squared error\n",
        "trainScore = np.sqrt(mean_squared_error(trainY[0], trainPredict[:,0]))\n",
        "print('Train Score: %.2f RMSE' % (trainScore))\n",
        "testScore = np.sqrt(mean_squared_error(testY[0], testPredict[:,0]))\n",
        "print('Test Score: %.2f RMSE' % (testScore))\n",
        "\n",
        "\n",
        "\n",
        "print('Time taken for prediction: {:.2f} seconds'.format(end_time - start_time))\n",
        "\n",
        "# shift train predictions for plotting\n",
        "trainPredictPlot = np.empty_like(dataset)\n",
        "trainPredictPlot[:, :] = np.nan\n",
        "trainPredictPlot[look_back:len(trainPredict)+look_back, :] = trainPredict\n",
        "# shift test predictions for plotting\n",
        "testPredictPlot = np.empty_like(dataset)\n",
        "testPredictPlot[:, :] = np.nan\n",
        "testPredictPlot[len(trainPredict)+(look_back*2)+1:len(dataset)-1, :] = testPredict\n",
        "# plot baseline and predictions\n",
        "plt.plot(scaler.inverse_transform(dataset))\n",
        "plt.plot(trainPredictPlot)\n",
        "plt.plot(testPredictPlot)\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "iTt7B9Wpo5kL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 317
        },
        "outputId": "5d7900d5-3ffa-480b-bffd-3468c4935114"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train Score: 16.32 RMSE\n",
            "Test Score: 24.77 RMSE\n",
            "Time taken for prediction: 2.61 seconds\n"
          ]
        },
        {
          "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": [
        "model.save('/content/gdrive/My Drive/modelgru&lstm.h5')"
      ],
      "metadata": {
        "id": "eooQZmLsCzlo"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.save_weights('path_to_saved_weights.h5')"
      ],
      "metadata": {
        "id": "besjMcf_FKPC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "StmpwE0VFK3j"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}