gru.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.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": "37017ced-931c-41fd-87f6-82c0c3887365"
      },
      "execution_count": 5,
      "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": "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\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": "0af7c182-c44d-4433-b0c4-a12d47d3ef48"
      },
      "execution_count": 11,
      "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": 12,
      "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()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H3DpzHhqeHJJ",
        "outputId": "54565a59-5662-4aaf-aeda-64dc2f1f1057"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential_3\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " bidirectional (Bidirectiona  (None, 128)              25728     \n",
            " l)                                                              \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 128)               0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 1)                 129       \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 25,857\n",
            "Trainable params: 25,857\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "Model: \"sequential_4\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " gru_2 (GRU)                 (None, 64)                12864     \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 8)                 520       \n",
            "                                                                 \n",
            " dense_2 (Dense)             (None, 1)                 9         \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 13,393\n",
            "Trainable params: 13,393\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\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",
        "trainPredict = model4.predict(trainX)\n",
        "testPredict = model4.predict(testX)\n",
        "# invert predictions\n",
        "trainPredict = scaler.inverse_transform(trainPredict)\n",
        "trainY = scaler.inverse_transform([trainY])\n",
        "testPredict = scaler.inverse_transform(testPredict)\n",
        "testY = scaler.inverse_transform([testY])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EYAb-dIVfS-S",
        "outputId": "87e8f84a-b934-44c3-fada-3dd1875cf82e"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "421/421 [==============================] - 2s 4ms/step\n",
            "181/181 [==============================] - 1s 4ms/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": "29ace3d5-2069-4fa7-9c39-2b701cb81a9e"
      },
      "execution_count": 16,
      "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": [
        "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",
        "# 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": 300
        },
        "outputId": "703dc314-c074-47fb-92d2-2cfd65a5a208"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train Score: 14.72 RMSE\n",
            "Test Score: 20.89 RMSE\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/modelgru2.h5')"
      ],
      "metadata": {
        "id": "eooQZmLsCzlo",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 330
        },
        "outputId": "f935cb5a-f935-430b-953b-4bb8912ae111"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-19-2ae2af8933c8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'/content/gdrive/My Drive/modelgru2.h5'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\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     68\u001b[0m             \u001b[0;31m# To get the full stack trace, call:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;31m# `tf.debugging.disable_traceback_filtering()`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m         \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m             \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\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;36m_assert_weights_created\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   3543\u001b[0m             \u001b[0;31m# Also make sure to exclude Model class itself which has build()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3544\u001b[0m             \u001b[0;31m# defined.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3545\u001b[0;31m             raise ValueError(\n\u001b[0m\u001b[1;32m   3546\u001b[0m                 \u001b[0;34mf\"Weights for model {self.name} have not yet been \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3547\u001b[0m                 \u001b[0;34m\"created. \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: Weights for model sequential_1 have not yet been created. Weights are created when the Model is first called on inputs or `build()` is called with an `input_shape`."
          ]
        }
      ]
    },
    {
      "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": []
    }
  ]
}