colab_notebook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "<Bertrand><Kwibuka>.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Installing and running libraries"
      ],
      "metadata": {
        "id": "JOSaRn1xwKxh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#installing folium for better visualisations \n",
        "\n",
        "!pip install folium"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hIYdistI3dHW",
        "outputId": "cad8de3a-fa38-4a43-8da7-5a9601195389"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: folium in /usr/local/lib/python3.7/dist-packages (0.8.3)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from folium) (1.15.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from folium) (1.19.5)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from folium) (2.23.0)\n",
            "Requirement already satisfied: branca>=0.3.0 in /usr/local/lib/python3.7/dist-packages (from folium) (0.4.2)\n",
            "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from folium) (2.11.3)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->folium) (2.0.1)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->folium) (2.10)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->folium) (1.24.3)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->folium) (3.0.4)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->folium) (2021.10.8)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "Ez0rkWlWodp_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a96d3bf-068d-4130-dcbc-b7d3fcf65a68"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: neptune-client in /usr/local/lib/python3.7/dist-packages (0.14.2)\n",
            "Requirement already satisfied: future>=0.17.1 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (0.18.2)\n",
            "Requirement already satisfied: websocket-client!=1.0.0,>=0.35.0 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (1.2.3)\n",
            "Requirement already satisfied: boto3>=1.16.0 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (1.20.46)\n",
            "Requirement already satisfied: requests-oauthlib>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (1.3.0)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from neptune-client) (1.1.5)\n",
            "Requirement already satisfied: psutil in /usr/local/lib/python3.7/dist-packages (from neptune-client) (5.4.8)\n",
            "Requirement already satisfied: Pillow>=1.1.6 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (7.1.2)\n",
            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (1.15.0)\n",
            "Requirement already satisfied: bravado in /usr/local/lib/python3.7/dist-packages (from neptune-client) (11.0.3)\n",
            "Requirement already satisfied: requests>=2.20.0 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (2.23.0)\n",
            "Requirement already satisfied: GitPython>=2.0.8 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (3.1.26)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (1.25.11)\n",
            "Requirement already satisfied: click>=7.0 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (7.1.2)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from neptune-client) (21.3)\n",
            "Requirement already satisfied: PyJWT in /usr/local/lib/python3.7/dist-packages (from neptune-client) (2.3.0)\n",
            "Requirement already satisfied: swagger-spec-validator>=2.7.4 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (2.7.4)\n",
            "Requirement already satisfied: oauthlib>=2.1.0 in /usr/local/lib/python3.7/dist-packages (from neptune-client) (3.1.1)\n",
            "Requirement already satisfied: jmespath<1.0.0,>=0.7.1 in /usr/local/lib/python3.7/dist-packages (from boto3>=1.16.0->neptune-client) (0.10.0)\n",
            "Requirement already satisfied: s3transfer<0.6.0,>=0.5.0 in /usr/local/lib/python3.7/dist-packages (from boto3>=1.16.0->neptune-client) (0.5.0)\n",
            "Requirement already satisfied: botocore<1.24.0,>=1.23.46 in /usr/local/lib/python3.7/dist-packages (from boto3>=1.16.0->neptune-client) (1.23.46)\n",
            "Requirement already satisfied: python-dateutil<3.0.0,>=2.1 in /usr/local/lib/python3.7/dist-packages (from botocore<1.24.0,>=1.23.46->boto3>=1.16.0->neptune-client) (2.8.2)\n",
            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from GitPython>=2.0.8->neptune-client) (3.10.0.2)\n",
            "Requirement already satisfied: gitdb<5,>=4.0.1 in /usr/local/lib/python3.7/dist-packages (from GitPython>=2.0.8->neptune-client) (4.0.9)\n",
            "Requirement already satisfied: smmap<6,>=3.0.1 in /usr/local/lib/python3.7/dist-packages (from gitdb<5,>=4.0.1->GitPython>=2.0.8->neptune-client) (5.0.0)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.20.0->neptune-client) (3.0.4)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.20.0->neptune-client) (2021.10.8)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.20.0->neptune-client) (2.10)\n",
            "Requirement already satisfied: jsonschema in /usr/local/lib/python3.7/dist-packages (from swagger-spec-validator>=2.7.4->neptune-client) (4.3.3)\n",
            "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from swagger-spec-validator>=2.7.4->neptune-client) (3.13)\n",
            "Requirement already satisfied: msgpack in /usr/local/lib/python3.7/dist-packages (from bravado->neptune-client) (1.0.3)\n",
            "Requirement already satisfied: bravado-core>=5.16.1 in /usr/local/lib/python3.7/dist-packages (from bravado->neptune-client) (5.17.0)\n",
            "Requirement already satisfied: simplejson in /usr/local/lib/python3.7/dist-packages (from bravado->neptune-client) (3.17.6)\n",
            "Requirement already satisfied: monotonic in /usr/local/lib/python3.7/dist-packages (from bravado->neptune-client) (1.6)\n",
            "Requirement already satisfied: jsonref in /usr/local/lib/python3.7/dist-packages (from bravado-core>=5.16.1->bravado->neptune-client) (0.2)\n",
            "Requirement already satisfied: pytz in /usr/local/lib/python3.7/dist-packages (from bravado-core>=5.16.1->bravado->neptune-client) (2018.9)\n",
            "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (21.4.0)\n",
            "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (4.10.1)\n",
            "Requirement already satisfied: pyrsistent!=0.17.0,!=0.17.1,!=0.17.2,>=0.14.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (0.18.1)\n",
            "Requirement already satisfied: importlib-resources>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (5.4.0)\n",
            "Requirement already satisfied: rfc3339-validator in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (0.1.4)\n",
            "Requirement already satisfied: webcolors>=1.11 in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (1.11.1)\n",
            "Requirement already satisfied: rfc3987 in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (1.3.8)\n",
            "Requirement already satisfied: jsonpointer>1.13 in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (2.2)\n",
            "Requirement already satisfied: fqdn in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (1.5.1)\n",
            "Requirement already satisfied: isoduration in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (20.11.0)\n",
            "Requirement already satisfied: uri-template in /usr/local/lib/python3.7/dist-packages (from jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (1.1.0)\n",
            "Requirement already satisfied: zipp>=3.1.0 in /usr/local/lib/python3.7/dist-packages (from importlib-resources>=1.4.0->jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (3.7.0)\n",
            "Requirement already satisfied: cached-property>=1.3.0 in /usr/local/lib/python3.7/dist-packages (from fqdn->jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (1.5.2)\n",
            "Requirement already satisfied: arrow>=0.15.0 in /usr/local/lib/python3.7/dist-packages (from isoduration->jsonschema->swagger-spec-validator>=2.7.4->neptune-client) (1.2.2)\n",
            "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->neptune-client) (3.0.7)\n",
            "Requirement already satisfied: numpy>=1.15.4 in /usr/local/lib/python3.7/dist-packages (from pandas->neptune-client) (1.19.5)\n"
          ]
        }
      ],
      "source": [
        "#installing neptune client\n",
        "\n",
        "!pip install neptune-client\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#import neptune \n",
        "\n",
        "import neptune.new as neptune "
      ],
      "metadata": {
        "id": "3jL1owdmqIji"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Connect your code to Neptune new version \n",
        "import os\n",
        "myProject = 'gaelkbertrand/google-stock-prediction'\n",
        "\n",
        "neptune.init(project=myProject, \n",
        "             api_token='eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI4YTc4ZTU1My01NGY3LTQ2YmMtODMxMi1iZWYxMzY4ZjQ2YzMifQ==')\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SmLVOqHcmVMX",
        "outputId": "8248cc18-6128-498f-c1f5-470aa87b4325"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://app.neptune.ai/gaelkbertrand/google-stock-prediction/e/GOOG-2\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Info (NVML): Driver Not Loaded. GPU usage metrics may not be reported. For more information, see https://docs.neptune.ai/you-should-know/what-can-you-log-and-display#hardware-consumption\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Remember to stop your run once you’ve finished logging your metadata (https://docs.neptune.ai/api-reference/run#.stop). It will be stopped automatically only when the notebook kernel/interactive console is terminated.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<neptune.new.run.Run at 0x7fb1fa115c90>"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#running neptune to log runs: not necessary if the above line run perfectly \n",
        "\n",
        "#run = neptune.init(project=project_name, api_token=api_token)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bbAwx4PPs76d",
        "outputId": "1801778a-c88e-4935-d3cc-0073f4ecb50a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://app.neptune.ai/gaelkbertrand/google-stock-prediction/e/GOOG-1\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Info (NVML): Driver Not Loaded. GPU usage metrics may not be reported. For more information, see https://docs.neptune.ai/you-should-know/what-can-you-log-and-display#hardware-consumption\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Remember to stop your run once you’ve finished logging your metadata (https://docs.neptune.ai/api-reference/run#.stop). It will be stopped automatically only when the notebook kernel/interactive console is terminated.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Setting up a Google Drive working directory"
      ],
      "metadata": {
        "id": "lZkI6zM68oE0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#setting up a working_directory \n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive', force_remount=True)\n",
        "\n",
        "! ls /content/drive/My\\ Drive/1.ASP2022\n",
        "\n",
        "import os\n",
        "# This helps you setup your working directory to a folder in your Google Drive.\n",
        "# Your files should be saved in your Google Drive!\n",
        "\n",
        "# the base Google Drive directory\n",
        "root_dir = \"/content/drive/My Drive/\"\n",
        "\n",
        "# choose where you want your project files to be saved\n",
        "ML_final_project = \"1.ASP2022/iml_final_project\"\n",
        "\n",
        "def create_and_set_working_directory(ML_final_project):\n",
        "  # check if your project folder exists. if not, it will be created.\n",
        "  if os.path.isdir(root_dir + ML_final_project) == False:\n",
        "    os.mkdir(root_dir + ML_final_project)\n",
        "    print(root_dir + ML_final_project + ' did not exist but was created.')\n",
        "\n",
        "  # change the OS to use your project folder as the working directory\n",
        "  os.chdir(root_dir + ML_final_project)\n",
        "\n",
        "  # create a test file to make sure it shows up in the right place\n",
        "  !touch 'new_file_in_working_directory.txt'\n",
        "  print('\\nYour working directory was changed to ' + root_dir + ML_final_project + \\\n",
        "        \"\\n\\nAn empty text file was created there. You can also run !pwd to confirm the current working directory.\" )\n",
        "\n",
        "create_and_set_working_directory(ML_final_project)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uKV2WKqq9Mkx",
        "outputId": "91b9ae3d-6bc6-4059-b0cf-802a8bd3de6a"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n",
            " 20220112_201807.mp4  'Calendars '\n",
            "'Academic Documents'  'My account info.zip'\n",
            "'Action plans'\t       new_file_in_working_directory.txt\n",
            " Assignments\t      'Online gaming competition Tech Min.pptx'\n",
            "'Bank complaints'      Research\n",
            " Bullshit\t       Work\n",
            "/content/drive/My Drive/1.ASP2022/iml_final_project did not exist but was created.\n",
            "\n",
            "Your working directory was changed to /content/drive/My Drive/1.ASP2022/iml_final_project\n",
            "\n",
            "An empty text file was created there. You can also run !pwd to confirm the current working directory.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Install other libraries for ML"
      ],
      "metadata": {
        "id": "FAlD-8NM8tfP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#installing other dependencies \n",
        "\n",
        "import os\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "# for reproducibility of my prediction results\n",
        "np.random.seed(42)\n",
        "\n",
        "from datetime import date\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
        "from keras.models import Sequential, Model\n",
        "from keras.models import Model\n",
        "from keras.layers import Dense, Dropout, LSTM, Input, Activation, concatenate\n",
        "\n",
        "import tensorflow as tf\n",
        "tf.random.set_seed(42)\n",
        "\n",
        "\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import datetime as dt\n",
        "import urllib.request, json\n",
        "os.chdir('/content/drive/My Drive/1.ASP2022/iml_final_project')\n"
      ],
      "metadata": {
        "id": "zC_76i362vpV"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Recheck and verify your working directory"
      ],
      "metadata": {
        "id": "c3JFKUMh8yAP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pwd"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "63jw07Hb6-4c",
        "outputId": "20a40b15-6af9-4326-f43d-2ccee7043056"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/drive/My Drive/1.ASP2022/iml_final_project\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# The ML project"
      ],
      "metadata": {
        "id": "1rwZONVuwSe4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Importing Google.inc stock data from Alpha Vantage"
      ],
      "metadata": {
        "id": "VZ6rXPtY1LAE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#import data from 'Alpha Vantage'\n",
        "\n",
        "data_source= 'alphavantage'\n",
        "\n",
        "if data_source == 'alphavantage':\n",
        "    \n",
        "    api_key = 'eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI4YTc4ZTU1My01NGY3LTQ2YmMtODMxMi1iZWYxMzY4ZjQ2YzMifQ=='\n",
        "    # here, write your desired stock ticker symbol\n",
        "    ticker = 'GOOGL' \n",
        "    \n",
        "    # This is the JSON file with all the stock prices data \n",
        "    url_string = \"https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol=%s&outputsize=full&apikey=%s\"%(ticker,api_key)\n",
        "\n",
        "    # Save data to this file\n",
        "    fileName = 'stock_market_data-%s.csv'%ticker\n",
        "\n",
        "    ### get the low, high, close, and open prices \n",
        "    if not os.path.exists(fileName):\n",
        "        with urllib.request.urlopen(url_string) as url:\n",
        "            data = json.loads(url.read().decode())\n",
        "            # pull the desired stock market data\n",
        "            data = data['Time Series (Daily)']\n",
        "            df = pd.DataFrame(columns=['Date','Low','High','Close','Open'])\n",
        "            for key,val in data.items():\n",
        "                date = dt.datetime.strptime(key, '%Y-%m-%d')\n",
        "                data_row = [date.date(),float(val['3. low']),float(val['2. high']),\n",
        "                            float(val['4. close']),float(val['1. open'])]\n",
        "                df.loc[-1,:] = data_row\n",
        "                df.index = df.index + 1\n",
        "        df.to_csv(fileName)\n",
        "\n",
        "    else:\n",
        "        print('Loading data from local')\n",
        "        df = pd.read_csv(fileName)"
      ],
      "metadata": {
        "id": "Jle6CXDEwV7F"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Data preprocessing "
      ],
      "metadata": {
        "id": "5LcAATRK1OWi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Sort this DataFrame by date\n",
        "stockprices = df.sort_values('Date')"
      ],
      "metadata": {
        "id": "zug3tCyl1SR2"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define functions that helps in calculating the performance: RMSE (Root Mean Square Error), MAPE (Mean absolute percentage error)"
      ],
      "metadata": {
        "id": "JwZc3tlwFot_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#### Define helper functions to calculate the metrics RMSE and MAPE ####\n",
        "def calculate_rmse(y_true, y_pred):\n",
        "    \"\"\"\n",
        "    Here, you can calculate the Root Mean Squared Error (RMSE)  \n",
        "    \"\"\"\n",
        "    rmse = np.sqrt(np.mean((y_true-y_pred)**2))                   \n",
        "    return rmse\n",
        "\n",
        "### The effectiveness of prediction method is measured in terms of the Mean Absolute Percentage Error (MAPE) and RMSE\n",
        "def calculate_mape(y_true, y_pred): \n",
        "    \"\"\"\n",
        "    Here, you can calculate the Mean Absolute Percentage Error (MAPE) %\n",
        "    \"\"\"\n",
        "    y_pred, y_true = np.array(y_pred), np.array(y_true)    \n",
        "    mape = np.mean(np.abs((y_true-y_pred) / y_true))*100    \n",
        "    return mape"
      ],
      "metadata": {
        "id": "SnrPU1IaF-i9"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Splitting the data into a training and test set"
      ],
      "metadata": {
        "id": "yaVM6HAlGUuP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Split the time-series data into a training sequence X and output value Y\n",
        "def extract_seqX_outcomeY(data, N, offset):\n",
        "    \"\"\"\n",
        "    Arguments explanation:\n",
        "        data - dataset \n",
        "        N - window size, e.g., 60 for 60 days \n",
        "        offset - position to start the split\n",
        "    \"\"\"\n",
        "    X, y = [], []\n",
        "    \n",
        "    for i in range(offset, len(data)):\n",
        "        X.append(data[i-N:i])\n",
        "        y.append(data[i])\n",
        "    \n",
        "    return np.array(X), np.array(y)\n",
        "\n",
        "\n",
        "#### Train-Test split for time-series ####\n",
        "test_ratio = 0.2\n",
        "training_ratio = 1 - test_ratio\n",
        "\n",
        "train_size = int(training_ratio * len(stockprices))\n",
        "test_size = int(test_ratio * len(stockprices))\n",
        "\n",
        "print(\"train_size: \" + str(train_size))\n",
        "print(\"test_size: \" + str(test_size))\n",
        "\n",
        "train = stockprices[:train_size][['Date', 'Close']]\n",
        "test = stockprices[train_size:][['Date', 'Close']]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uBOM565CGYxq",
        "outputId": "71360029-d37d-4b47-fb61-9fa39a34b735"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_size: 3514\n",
            "test_size: 878\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# The LSTM (Long Short Term Memory) Model"
      ],
      "metadata": {
        "id": "wVC-QPWmHjKb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Simple Moving Average calculation"
      ],
      "metadata": {
        "id": "yr3BT3IT_ery"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stockprices = stockprices.set_index('Date')\n",
        "\n",
        "### For meduim-term trading \n",
        "def plot_stock_trend(var, cur_title, stockprices=stockprices, logNeptune=True, logmodelName='Simple MA'):\n",
        "    ax = stockprices[['Close', var,'200day']].plot(figsize=(20, 10))\n",
        "    plt.grid(False)\n",
        "    plt.title(cur_title)\n",
        "    plt.axis('tight')\n",
        "    plt.ylabel('Stock Price ($)')\n",
        "    \n",
        "    if logNeptune:\n",
        "        npt_exp.log_image(f'Plot of Stock Predictions with {logmodelName}', ax.get_figure())\n",
        "        \n",
        "def calculate_perf_metrics(var, logNeptune=True, logmodelName='Simple MA'):\n",
        "    ### RMSE \n",
        "    rmse = calculate_rmse(np.array(stockprices[train_size:]['Close']), np.array(stockprices[train_size:][var]))\n",
        "    ### MAPE \n",
        "    mape = calculate_mape(np.array(stockprices[train_size:]['Close']), np.array(stockprices[train_size:][var]))\n",
        "    \n",
        "    if logNeptune:        \n",
        "        npt_exp.send_metric('RMSE', rmse)\n",
        "        npt_exp.log_metric('RMSE', rmse)\n",
        "        \n",
        "        npt_exp.send_metric('MAPE (%)', mape)\n",
        "        npt_exp.log_metric('MAPE (%)', mape)\n",
        "    \n",
        "    return rmse, mape\n",
        "\n",
        "# Here, 20 days represent the 22 trading days in a month\n",
        "window_size = 50\n",
        "CURRENT_MODEL = 'LSTM'"
      ],
      "metadata": {
        "id": "ZfX3GNl1HuPs"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The model"
      ],
      "metadata": {
        "id": "qmqA0zggJBZz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#The model based on the model built by: Neptune.AI (https://neptune.ai/). Treat this as a formal citation of a reference. \n",
        "\n",
        "#neptune.create_experiment()\n",
        "\n",
        "if CURRENT_MODEL == 'LSTM':\n",
        "\n",
        "  layer_units, optimizer = 50, 'adam' \n",
        "  cur_epochs = 15\n",
        "  cur_batch_size = 20\n",
        "\n",
        "  cur_LSTM_pars = {'units': layer_units, \n",
        "                    'optimizer': optimizer, \n",
        "                    'batch_size': cur_batch_size, \n",
        "                    'epochs': cur_epochs\n",
        "                    }\n",
        "\n",
        " # Create an experiment and log the model in Neptune new verison\n",
        "  npt_exp = neptune.init(    \n",
        "      api_token=\"eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI4YTc4ZTU1My01NGY3LTQ2YmMtODMxMi1iZWYxMzY4ZjQ2YzMifQ==\",\n",
        "      project=myProject, \n",
        "      name='LSTM',         \n",
        "      description='Google-stock-prediction-machine-learning', \n",
        "      tags=['stockprediction', 'LSTM','neptune'])   \n",
        "  \n",
        "  npt_exp['LSTMPars'] = cur_LSTM_pars\n",
        "\n",
        "\n",
        "## Here, you have to use the past N stock prices for training to predict the N+1th closing price\n",
        "\n",
        " # scale \n",
        "scaler = StandardScaler()\n",
        "scaled_data = scaler.fit_transform(stockprices[['Close']])\n",
        "scaled_data_train = scaled_data[:train.shape[0]]\n",
        "\n",
        "X_train, y_train = extract_seqX_outcomeY(scaled_data_train, window_size, window_size)\n",
        "\n",
        "### Build the LSTM model and log your model summary to Neptune to check on performance ###    \n",
        "def Run_LSTM(X_train, layer_units=50, logNeptune=True, NeptuneProject=None):     \n",
        "    inp = Input(shape=(X_train.shape[1], 1))\n",
        "    \n",
        "    x = LSTM(units=layer_units, return_sequences=True)(inp)\n",
        "    x = LSTM(units=layer_units)(x)\n",
        "    out = Dense(1, activation='linear')(x)\n",
        "    model = Model(inp, out)\n",
        "    \n",
        "    # Compile the LSTM neural network\n",
        "    model.compile(loss = 'mean_squared_error', optimizer = 'adam')\n",
        "    \n",
        "    ## log into Neptune\n",
        "   \n",
        "    if logNeptune:\n",
        "            model.summary(print_fn=lambda x: NeptuneProject['model_summary'].log(x))\n",
        "    return model \n",
        "\n",
        "#Run the model\n",
        "model = Run_LSTM(X_train, layer_units=layer_units, logNeptune=True, NeptuneProject=npt_exp)\n",
        "    \n",
        "history = model.fit(X_train, y_train, epochs=cur_epochs, batch_size=cur_batch_size, \n",
        "                    verbose=1, validation_split=0.1, shuffle=True)\n",
        "\n",
        "#Now, you can predict stock prices using the past window_size stock prices\n",
        "def preprocess_testdat(data=stockprices, scaler=scaler, window_size=window_size, test=test):    \n",
        "    raw = data['Close'][len(data) - len(test) - window_size:].values\n",
        "    raw = raw.reshape(-1,1)\n",
        "    raw = scaler.transform(raw)\n",
        "    \n",
        "    X_test = []\n",
        "    for i in range(window_size, raw.shape[0]):\n",
        "        X_test.append(raw[i-window_size:i, 0])\n",
        "        \n",
        "    X_test = np.array(X_test)\n",
        "    \n",
        "    X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1))\n",
        "    return X_test\n",
        "\n",
        "#Run it\n",
        "X_test = preprocess_testdat()\n",
        "  \n",
        "predicted_price_ = model.predict(X_test)\n",
        "predicted_price = scaler.inverse_transform(predicted_price_)\n",
        "\n",
        "# Plot the predicted price versus the actual closing price \n",
        "test['Predictions_lstm'] = predicted_price   \n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d_CMzXE5I7T1",
        "outputId": "59d93ff4-b0f5-4f42-f31e-3ceaf4d5a87e"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "https://app.neptune.ai/gaelkbertrand/google-stock-prediction/e/GOOG-8\n",
            "Remember to stop your run once you’ve finished logging your metadata (https://docs.neptune.ai/api-reference/run#.stop). It will be stopped automatically only when the notebook kernel/interactive console is terminated.\n",
            "Epoch 1/15\n",
            "156/156 [==============================] - 21s 112ms/step - loss: 0.0114 - val_loss: 0.0041\n",
            "Epoch 2/15\n",
            "156/156 [==============================] - 17s 106ms/step - loss: 0.0030 - val_loss: 0.0038\n",
            "Epoch 3/15\n",
            "156/156 [==============================] - 18s 113ms/step - loss: 0.0025 - val_loss: 0.0028\n",
            "Epoch 4/15\n",
            "156/156 [==============================] - 20s 131ms/step - loss: 0.0022 - val_loss: 0.0031\n",
            "Epoch 5/15\n",
            "156/156 [==============================] - 18s 115ms/step - loss: 0.0020 - val_loss: 0.0027\n",
            "Epoch 6/15\n",
            "156/156 [==============================] - 19s 125ms/step - loss: 0.0018 - val_loss: 0.0024\n",
            "Epoch 7/15\n",
            "156/156 [==============================] - 17s 111ms/step - loss: 0.0016 - val_loss: 0.0035\n",
            "Epoch 8/15\n",
            "156/156 [==============================] - 17s 106ms/step - loss: 0.0015 - val_loss: 0.0027\n",
            "Epoch 9/15\n",
            "156/156 [==============================] - 17s 110ms/step - loss: 0.0014 - val_loss: 0.0039\n",
            "Epoch 10/15\n",
            "156/156 [==============================] - 18s 115ms/step - loss: 0.0013 - val_loss: 0.0019\n",
            "Epoch 11/15\n",
            "156/156 [==============================] - 20s 130ms/step - loss: 0.0013 - val_loss: 0.0019\n",
            "Epoch 12/15\n",
            "156/156 [==============================] - 17s 112ms/step - loss: 0.0012 - val_loss: 0.0019\n",
            "Epoch 13/15\n",
            "156/156 [==============================] - 18s 117ms/step - loss: 0.0012 - val_loss: 0.0017\n",
            "Epoch 14/15\n",
            "156/156 [==============================] - 17s 108ms/step - loss: 0.0011 - val_loss: 0.0018\n",
            "Epoch 15/15\n",
            "156/156 [==============================] - 17s 108ms/step - loss: 0.0011 - val_loss: 0.0016\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/sklearn/base.py:451: UserWarning: X does not have valid feature names, but StandardScaler was fitted with feature names\n",
            "  \"X does not have valid feature names, but\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Performance Evaluation"
      ],
      "metadata": {
        "id": "f-jMLpvxtS7e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Evaluating the performance via RMSE and MAPE"
      ],
      "metadata": {
        "id": "x0mV0LvvtePV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rmse_lstm = calculate_rmse(np.array(test['Close']), np.array(test['Predictions_lstm']))\n",
        "mape_lstm = calculate_mape(np.array(test['Close']), np.array(test['Predictions_lstm']))\n",
        "# npt_exp.send_metric('RMSE', rmse_lstm)\n",
        "# npt_exp.log_metric('RMSE', rmse_lstm)\n",
        "npt_exp['RMSE'].log(rmse_lstm)  ## 12-18\n",
        "\n",
        "# npt_exp.send_metric('MAPE (%)', mape_lstm)\n",
        "# npt_exp.log_metric('MAPE (%)', mape_lstm)\n",
        "npt_exp['MAPE (%)'].log(mape_lstm)\n",
        "\n",
        "print('RMSE=', rmse_lstm, ':An error difference of 114. Pretty low compared to how Google stock changed in the last 18 years')\n",
        "print('MAPE % =', mape_lstm, ':Good performance. An error of 3% difference between the actual price vs the predicted price.')"
      ],
      "metadata": {
        "id": "0J6KNLhetc9d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "32e73fc5-57e2-47c0-dba2-9d478b846713"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "RMSE= 114.38063218855103 :An error difference of 114. Pretty low compared to how Google stock changed in the last 18 years\n",
            "MAPE % = 3.354019131687904 :Good performance. An error of 3% difference between the actual price vs the predicted price.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Plotting Function Definition\n",
        "\n",
        "Note: if you have color blindness, specify your preferred colors in the code below. "
      ],
      "metadata": {
        "id": "GL9lt-a0t7fn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "### Plot prediction and true trends and log to Neptune         \n",
        "def plot_stock_trend_lstm(train, test, logNeptune=True):        \n",
        "    fig = plt.figure(figsize = (20,10))\n",
        "    plt.plot(train['Date'], train['Close'], label = 'TRAIN Closing Price')\n",
        "    plt.plot(test['Date'], test['Close'], label = 'TEST Closing Price')\n",
        "    plt.plot(test['Date'], test['Predictions_lstm'], label = 'Predicted Closing Price')\n",
        "    plt.title('Google inc stock price prediction using the LSTM Model: 2004-2022')\n",
        "    plt.xlabel('Date')\n",
        "    plt.ylabel('Stock Price ($)')\n",
        "    plt.legend(loc=\"upper left\")\n",
        "    \n",
        "    ## Log image to Neptune new version\n",
        "    if logNeptune:\n",
        "        ## npt_exp.log_image('Plot of Stock Predictions with LSTM', fig)\n",
        "        npt_exp['Plot of Stock Predictions with LSTM'].upload(neptune.types.File.as_image(fig))        "
      ],
      "metadata": {
        "id": "Frb51UwXt68-"
      },
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Plotting "
      ],
      "metadata": {
        "id": "4RHII8geuLVW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plot_stock_trend_lstm(train, test)\n",
        "print('RMSE=', rmse_lstm, ':An error difference of 114. Pretty low compared to how Google stock changed in the last 18 years')\n",
        "print('MAPE % =', mape_lstm, ':Good performance. An error of 3% difference between the actual price vs the predicted price.')"
      ],
      "metadata": {
        "id": "5D63hbhXuKH5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 656
        },
        "outputId": "a1717632-b024-441b-b2f8-3c4b593715f7"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "RMSE= 114.38063218855103 :An error difference of 114. Pretty low compared to how Google stock changed in the last 18 years\n",
            "MAPE % = 3.354019131687904 :Good performance. An error of 3% difference between the actual price vs the predicted price.\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Stop the experiment "
      ],
      "metadata": {
        "id": "E6r6QjgmuQMZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "npt_exp.stop()"
      ],
      "metadata": {
        "id": "5Yu6QUfbuTf_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f973a434-8a89-4ed2-fa2b-f98c08078905"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shutting down background jobs, please wait a moment...\n",
            "Done!\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Waiting for the remaining 1 operations to synchronize with Neptune. Do not kill this process.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All 1 operations synced, thanks for waiting!\n"
          ]
        }
      ]
    }
  ]
}