LSTM_for_Colored_Noise.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "LSTM for Colored Noise.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/barauna-lo/CAP4213-Deep-Learning/blob/main/LSTM_for_Colored_Noise.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "erJ52FTN14tH"
      },
      "source": [
        "<img src=https://raw.githubusercontent.com/barauna-lo/CAP4213-Deep-Learning/main/logoinpe.png>\n",
        "\n",
        "\n",
        "# Investigating the performance of RNN (GRU and LSTM) to predict different classes of colored noise\n",
        "\n",
        "This code we gerenete Colored Noise from these python library [colorednoise](https://pypi.org/project/colorednoise/). We will also creating a datafreame for different values of $\\beta$ and creating a datafreame with theses data using pandas library. With these data, we expect to train a LSTM model for predict the signal of colored noise\n",
        "\n",
        "\n",
        "### <font color='red'>_Open Problemns_</font> \n",
        "\n",
        "* <font color='red'> Saving the csv with any elemenst has an array </font> \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AFLwfnwu14tO"
      },
      "source": [
        "On the next cell we will import the librarys\n",
        "\n",
        "\n",
        "</font>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dgOqTNud14tQ"
      },
      "source": [
        "!pip install colorednoise\n",
        "import colorednoise as cn\n",
        "from matplotlib import mlab\n",
        "from matplotlib import pylab as plt\n",
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJM1cJHR14tT"
      },
      "source": [
        "On next we will generata a Generate white noise for $\\beta = 0$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fxAi5QDC14tV"
      },
      "source": [
        "#input values\n",
        "beta = 0         # the exponent: 0=white noite; 1=pink noise;  2=red noise (also \"brownian noise\")\n",
        "samples = 2**16 # number of samples to generate (time series extension)\n",
        "#beta = [0,1,2]\n",
        "\n",
        "A0 = cn.powerlaw_psd_gaussian(beta, samples)\n",
        "A0 = np.append(beta,A0)\n",
        "\n",
        "plt.plot(A0, color='black', linewidth=0.2)\n",
        "plt.title('Colored Noise for β='+str(beta))\n",
        "plt.xlabel('Samples (time-steps)')\n",
        "plt.ylabel('Amplitude(t)', fontsize='large')\n",
        "#plt.savefig('Noise.pdf')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "btl-QIEd14tW"
      },
      "source": [
        "On the next cell we will generate the Power Spectrum Density function  also for $\\beta = 0$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iJzOt_Gq14tW"
      },
      "source": [
        "#Power Spectral Density(PSD) for A(t)\n",
        "spectrum, frequency = mlab.psd(A0, NFFT=2**13)\n",
        "plt.loglog(frequency,spectrum, color='black', linewidth=0.8)\n",
        "plt.title('Power Spectral Density of A(t) with β='+str(beta))\n",
        "plt.xlabel('Frequency')\n",
        "plt.ylabel('Power Spectrum Density', fontsize='large')\n",
        "\n",
        "plt.grid(True)\n",
        "#plt.savefig('PSD of A(t) with beta='+str(beta)+'.pdf')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-Lz0Lu6K14tY"
      },
      "source": [
        "On the cell below we will plot the two last chars in a single picture"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s7yrm11I14tZ"
      },
      "source": [
        "#Deffing the great figure size\n",
        "plt.figure(figsize=(15,5))\n",
        "\n",
        "#Ploting first subfiure\n",
        "plt.subplot(1,2,1)\n",
        "plt.plot(A0, color='black', linewidth=0.2)\n",
        "plt.title('Colored Noise for β='+str(beta))\n",
        "plt.xlabel('Samples (time-steps)')\n",
        "plt.ylabel('Amplitude(t)', fontsize='large')\n",
        "\n",
        "#Ploting second subfigure\n",
        "plt.subplot(122)\n",
        "spectrum, frequency = mlab.psd(A0, NFFT=2**13)\n",
        "plt.loglog(frequency,spectrum, color='black', linewidth=0.8)\n",
        "plt.title('Power Spectral Density of A(t) with β='+str(beta))\n",
        "plt.xlabel('Frequency')\n",
        "plt.ylabel('Power Spectrum Density', fontsize='large')\n",
        "plt.grid(True)\n",
        "\n",
        "#ploting the intire figure\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qr34OQ5j14tb"
      },
      "source": [
        "## Generating a DataFrame Using Pandas 🐼\n",
        "\n",
        "Now, we will allocate several time series in a dataframe with different colored noises for different values of $\\beta$. We will use pandas library for these Function. \n",
        "\n",
        "Below, there is a hidden cell for generating random values. For now, we just we wil creating some temporal series for witch $\\beta$ value. The variation to 0, from 3, in a step of 0.25"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nu_oVAf014tc"
      },
      "source": [
        "# import random as rd\n",
        "# beta = rd.uniform(0, 5) #generating a real number between the braket interval\n",
        "# beta = rd.randint(0, 5) #generating a interger number between the braket interval"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F3mpUpSa2UFi"
      },
      "source": [
        "# Import pandas library 🐼\n",
        "import pandas as pd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PlQH30u114td"
      },
      "source": [
        "\n",
        "# initialize list of lists\n",
        "data = []\n",
        "for i in range(0,13):\n",
        "    for j in range(0,10):\n",
        "        beta = round(i/4,2)\n",
        "        A = cn.powerlaw_psd_gaussian(beta, samples)  #genereting the amplitude noise\n",
        "        s, f = mlab.psd(A, NFFT=2**13)               #genereting the power spectrum density\n",
        "        data.append([beta,A,f,s])                    #allocating the genereted data in a matrix\n",
        "\n",
        "# Create the pandas DataFrame\n",
        "df = pd.DataFrame(data, columns = ['beta', 'Series','PSD','Frequency'])\n",
        "# Exporting the data frame from a .csv file\n",
        "#df.to_csv(r'colored_noise.csv')\n",
        "df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bDXiogzN2CDB"
      },
      "source": [
        "# Open problem\n",
        "\n",
        "On the next cell we will import on of the previus saved dataset generated on the first aplications. Even generating a new data frame, using this last on would be importat for furute comparisons"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9cUePzsQ2FZN"
      },
      "source": [
        "#df=pd.read_csv('https://www.dropbox.com/sh/ew55wdqbc519ayd/AAA7UQqs0opzEH_Rf7GLWEeea/tabela_painters.csv?dl=1') \n",
        "df1=pd.read_csv('https://www.dropbox.com/s/indlm4581h2838x/colored_noise_dataframe.csv?dl=1')\n",
        "#df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pwsZL_XgTONY"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1nWkCg7sAiBu"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j1bQgnyO-bB3"
      },
      "source": [
        "import re\n",
        "\n",
        "df1['Series'][0] == (re.sub(\"\\s+\", \",\", df1['Series'][0].strip()))\n",
        "#df1['Series'][0] == np.array(df1['Series'][0])\n",
        "df1['Series'][0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fOfU7rynF8NB"
      },
      "source": [
        "teste = np.array(re.sub(\"\\s+\", \",\", df1['Series'][0].strip()))\n",
        "teste2 = df1['Series'][0].strip('[').strip(']').replace(\"\\n\",\"\")\n",
        "teste2 = teste2.split()\n",
        "a = []\n",
        "for i in range(len(teste2)): a.append(float(teste2[i]))\n",
        "#teste1 = df['Series'][0]\n",
        "#plt.plot(teste1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wtDWd_RjG1k4"
      },
      "source": [
        "teste1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I5WhJFVz6V7o"
      },
      "source": [
        "df['Series'][0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j1ylXFYH3Lai"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZbYgkstE14te"
      },
      "source": [
        "On the next cell we will plot the some of these generate time series for $\\beta = 0$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "Np59n-GI98Pv",
        "jupyter": {
          "outputs_hidden": true
        }
      },
      "source": [
        "\n",
        "#Ploting\n",
        "plt.figure(figsize=(15,30))\n",
        "for i in range(0,10):\n",
        "    plt.subplot(5,2,i+1)\n",
        "    plt.plot(df['Series'][i], color='black', linewidth=0.2)\n",
        "    plt.title('Colored Noise for β='+str(df['beta'][i]))\n",
        "    plt.xlabel('Samples (time-steps)')\n",
        "    plt.ylabel('Amplitude(t)', fontsize='large')\n",
        "#plt.savefig('beta=0.jpg')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "jupyter": {
          "outputs_hidden": true
        },
        "id": "TNe8J91x14tf"
      },
      "source": [
        "\n",
        "#Ploting\n",
        "plt.figure(figsize=(15,30))\n",
        "for i in range(10,20):\n",
        "    plt.subplot(5,2,i-9)\n",
        "    plt.plot(df['Series'][i], color='black', linewidth=0.2)\n",
        "    plt.title('Colored Noise for β='+str(df['beta'][i]))\n",
        "    plt.xlabel('Samples (time-steps)')\n",
        "    plt.ylabel('Amplitude(t)', fontsize='large')\n",
        "    #plt.savefig('charts/beta=0.25.jpg')\n",
        "#plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SkeMhdqF14tf"
      },
      "source": [
        "Now we will creating a small gif of these series envolving  time"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zWyMpAQba4bb"
      },
      "source": [
        "#Ploting\n",
        "#plt.figure(figsize=(0,30))\n",
        "for i in range(0,len(df['beta']),10):\n",
        "    #plt.subplot(5,2,i-9)\n",
        "    plt.plot(df['Series'][i], color='black', linewidth=0.2)\n",
        "    plt.title('Colored Noise for β='+str(df['beta'][i]))\n",
        "    plt.xlabel('Samples (time-steps)')\n",
        "    plt.ylabel('Amplitude(t)', fontsize='large')\n",
        "    #plt.savefig('charts/beta='+str(df['beta'][i])+'.jpg')\n",
        "    #plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K1EzHuIy14tg"
      },
      "source": [
        "# LSTM \n",
        "## _Long Shott Term Memory_ \n",
        "Now we will introduce a Recurrent Neural Network (RNN) for these kind of RNN we will use the tensorflow library. From that library we will use the Keras for construct our LSTM model\n",
        "\n",
        "<img src=\"data:image/png;base64,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\">\n",
        "\n",
        "<img src=\"data:image/png;base64,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\" width = 400>\n",
        "\n",
        "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/NumPy_logo_2020.svg/2560px-NumPy_logo_2020.svg.png\" width =400>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0dyZqPAS14th"
      },
      "source": [
        "import numpy as np\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import LSTM\n",
        "from tensorflow.keras.layers import Dense\n",
        "from tensorflow.keras.layers import Flatten"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C93xU8Y-14ti"
      },
      "source": [
        "On the next cell we will creating a function similary to ```train_test_split``` from the ```sklearn``` library. The above logic is importante becouse we will define how many data the LSTM model will use for prodict the next step data. These functions will take the time series data and performe ir by the ```n_features``` data training.\n",
        "\n",
        "Its import to understand that in LSTM the predicted target will be next value of temporal serie based on a quantity on pre understood data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kKgd9k-n14ti"
      },
      "source": [
        "def prepare_data(timeseries_data, n_features):\n",
        "    X, y = [],[]\n",
        "    for i in range(len(timeseries_data)):\n",
        "        # Find the end of this pattern \n",
        "        end_ix = i + n_features\n",
        "        # check if we are beyond the Sequence\n",
        "        if end_ix > len(timeseries_data)-1:\n",
        "            break\n",
        "        # gather input and output parts of the pattern\n",
        "        seq_x, seq_y = timeseries_data[i:end_ix], timeseries_data[end_ix]\n",
        "        X.append(seq_x)\n",
        "        y.append(seq_y)\n",
        "    return np.array(X), np.array(y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S0LtHeX_14tj"
      },
      "source": [
        "### Prepering the data like sugest the boss:\n",
        "\n",
        "_pegue uma serie pequena com 50 pontos.  (pode ser um pedaco da serie para beta=2 -  qualquer uma das dez geradas).  Construa duas series testes: uma (teste1.csv)  com os primeiros 10 pontos e outra (teste2.csv) com 50 pontos. Aplique a LSTM que vc implementou sobre elas.  Comece com a de 10 pontos.  Tente prever o 11o ponto com passo 4, por exemplo.   Conta 4 e preve o 5o.  veja o exemplo do video._"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h3Gw2apg14tk"
      },
      "source": [
        "## We will defining a small time series data for only 10 values for $\\beta = 2$\n",
        "\n",
        "On the next cell que will chek the index of a $\\beta = 2$ temporal series"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3yYaue0U14tk"
      },
      "source": [
        "df['beta'][80]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wo5grUuX14tk"
      },
      "source": [
        "On the next cell we will will define a new ```timeseries_data``` and plot these time series. Here we defing a set of parameters for these time series wich is:\n",
        "\n",
        "* ``` serie_index ``` The id of the series in the dataframe\n",
        "* ``` min_size``` and ```max_size``` how define the size of the time series data used on the LSTM model\n",
        "* ``` n_step``` defing how many numbers in the time series will be used to learn"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QX3_RIcS14tl"
      },
      "source": [
        "# define input sequence\n",
        "\n",
        "serie_index = 80\n",
        "\n",
        "min_size , max_size = 0 , 50\n",
        "\n",
        "timeseries_data = df['Series'][serie_index][min_size:max_size]\n",
        "\n",
        "# choose a number of time steps\n",
        "n_steps = 4\n",
        "\n",
        "# split into samples\n",
        "X, y = prepare_data(timeseries_data, n_steps)\n",
        "\n",
        "#plt.plot(df[\"Series\"][0:10])\n",
        "plt.plot(timeseries_data, color='black', linewidth=1)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hfcn354i14tl"
      },
      "source": [
        "On next cell will print the data that will used for traing e test"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4sMnh7jJ14tl"
      },
      "source": [
        "print(X),print(y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cIxzsMz014tm"
      },
      "source": [
        "On next two cell we will plot the shape of ```X``` and _reshape_ the it. These numpy array must to have a 3 dimensional size. _(I dont know why)_"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4lA43laq14tm"
      },
      "source": [
        "X.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IRJC7Vkj14tm"
      },
      "source": [
        "# reshape from [samples, timesteps] into [samples, timesteps, features]\n",
        "n_features = 1\n",
        "X = X.reshape((X.shape[0], X.shape[1], n_features))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xfibf6TI14tn"
      },
      "source": [
        "# Building The Model\n",
        "On the next cell we will construc a LSTM model compose by two hindden layers with 50 neurons withc. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IVLL-atK14tn"
      },
      "source": [
        "# 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=500, verbose=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nIy1B07H14to"
      },
      "source": [
        "On the next cell we will agein redefing some parameters such as \n",
        "\n",
        "* ```inti``` how will fit the value of witch part of the data frame we will select to test\n",
        "* ```x_input``` will be a stat point fron the in the meadle (or not) data frame data having ```n_steps``` size\n",
        "* ```i``` is the inicial value for initial step ¿\n",
        "* ```f``` the value of the number of predicted values\n",
        "\n",
        "### ⚠️ ATENTION ⚠️\n",
        "\n",
        "The ```#```s in the ```while``` can be uncomented for print the step by step results"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u0J5H8TG14tp"
      },
      "source": [
        "# demonstrate prediction for next 10 days\n",
        "\n",
        "init = max_size - 3\n",
        "\n",
        "x_input = np.array(  df['Series'][serie_index][init:init + n_steps] ) # he is just working for n_stpes +1\n",
        "temp_input=list(x_input)\n",
        "\n",
        "lst_output=[]\n",
        "\n",
        "i=0\n",
        "f = 10. #number of newsteps\n",
        "while(i<f):\n",
        "# Não entendi muito bem o que ele fez aqui!\n",
        "    if(len(temp_input)>n_steps): # !!!! ON THE ORIGNINAL CODE THAT IS JUST 3 \n",
        "        x_input=np.array(temp_input[1:])\n",
        "#        print(\"{} day input {}\".format(i,x_input))\n",
        "        #print(x_input)\n",
        "        x_input = x_input.reshape((1, n_steps, n_features))\n",
        "        #print(x_input)\n",
        "        yhat = model.predict(x_input, verbose=0)\n",
        "#        print(\"{} day output {}\".format(i,yhat))\n",
        "        temp_input.append(yhat[0][0])\n",
        "        temp_input=temp_input[1:]\n",
        "        #print(temp_input)\n",
        "        lst_output.append(yhat[0][0])\n",
        "        i=i+1\n",
        "    else:\n",
        "        x_input = x_input.reshape((1, n_steps, n_features))\n",
        "        yhat = model.predict(x_input, verbose=0)\n",
        "#        print(yhat[0])\n",
        "        temp_input.append(yhat[0][0])\n",
        "        lst_output.append(yhat[0][0])\n",
        "        i=i+1\n",
        "    \n",
        "\n",
        "#print(lst_output)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KMfdpxrV14tq"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "day_new=np.arange(min_size , max_size)\n",
        "day_pred=np.arange(init,init+len(lst_output))\n",
        "plt.plot(day_new,timeseries_data,label='Selected Time Series')\n",
        "plt.plot(day_pred,lst_output,label='Predict Model')\n",
        "plt.plot(day_pred,df['Series'][serie_index][init:init+len(lst_output)],color='red',linewidth=1.5,label='Next Time Seires Data')\n",
        "#plt.ylim(-2.6,2.6)\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8R7H55gb14tq"
      },
      "source": [
        "## _One cell to rule them all_ 💍\n",
        "\n",
        "Now we will reconstroct the above cell in just two cells. The firt one will recreat the dataframe anf the second give all the results for some parameters. And we will traing for more datas and differte $\\beta$ value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QJVuAG0eWIp9"
      },
      "source": [
        "len(df['Series'][0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T5E2GiVD14tr"
      },
      "source": [
        "# define input sequence\n",
        "\n",
        "serie_index = 80\n",
        "\n",
        "min_size , max_size = 0 , 65530\n",
        "\n",
        "timeseries_data = df['Series'][serie_index][min_size:max_size]\n",
        "\n",
        "# choose a number of time steps\n",
        "n_steps = 4\n",
        "\n",
        "# split into samples\n",
        "X, y = prepare_data(timeseries_data, n_steps)\n",
        "\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",
        "\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=500, verbose=0)\n",
        "\n",
        "\n",
        "# demonstrate prediction for next 10 days\n",
        "\n",
        "init = max_size - 3\n",
        "\n",
        "x_input = np.array(  df['Series'][serie_index][init:init + n_steps] ) # he is just working for n_stpes +1\n",
        "temp_input=list(x_input)\n",
        "\n",
        "lst_output=[]\n",
        "\n",
        "i=0\n",
        "f = 10. #number of newsteps\n",
        "while(i<f):\n",
        "# Não entendi muito bem o que ele fez aqui!\n",
        "    if(len(temp_input)>n_steps): # !!!! ON THE ORIGNINAL CODE THAT IS JUST 3 \n",
        "        x_input=np.array(temp_input[1:])\n",
        "#        print(\"{} day input {}\".format(i,x_input))\n",
        "        #print(x_input)\n",
        "        x_input = x_input.reshape((1, n_steps, n_features))\n",
        "        #print(x_input)\n",
        "        yhat = model.predict(x_input, verbose=0)\n",
        "#        print(\"{} day output {}\".format(i,yhat))\n",
        "        temp_input.append(yhat[0][0])\n",
        "        temp_input=temp_input[1:]\n",
        "        #print(temp_input)\n",
        "        lst_output.append(yhat[0][0])\n",
        "        i=i+1\n",
        "    else:\n",
        "        x_input = x_input.reshape((1, n_steps, n_features))\n",
        "        yhat = model.predict(x_input, verbose=0)\n",
        "#        print(yhat[0])\n",
        "        temp_input.append(yhat[0][0])\n",
        "        lst_output.append(yhat[0][0])\n",
        "        i=i+1\n",
        "    \n",
        "\n",
        "#print(lst_output)\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "day_new=np.arange(min_size , max_size)\n",
        "day_pred=np.arange(init,init+len(lst_output))\n",
        "plt.plot(day_new,timeseries_data,label='Selected Time Series')\n",
        "plt.plot(day_pred,lst_output,label='Predict Model')\n",
        "plt.plot(day_pred,df['Series'][serie_index][init:init+len(lst_output)],color='red',linewidth=1.5,label='Next Time Seires Data')\n",
        "#plt.ylim(-2.6,2.6)\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wRnyzwzlV2G0"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}