lstm_basic.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyMrmZ3Hk5YBWQvwgMJn+BEy",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/beinghorizontal/Quantext/blob/main/lstm_basic.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow as tf\n",
        "physical_devices = tf.config.list_physical_devices('GPU')\n",
        "\n",
        "print(\"GPU:\", tf.config.list_physical_devices('GPU'))\n",
        "print(\"Num GPUs:\", len(physical_devices))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KzWBdJHKCxvy",
        "outputId": "e48f356b-d59c-47ba-bae1-2f22573426b7"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GPU: [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\n",
            "Num GPUs: 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "1PwrS4hYMiR7"
      },
      "outputs": [],
      "source": [
        "# Import necessary libraries\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "from pandas_datareader import data\n",
        "import datetime as dt\n",
        "from datetime import datetime\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import LSTM, Dense\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "get free API key from alpha- vantage and save in local file safely and import the file  https://www.alphavantage.co/support/#api-key"
      ],
      "metadata": {
        "id": "izMUMZGPEHI6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files\n",
        "\n",
        "# Choose the file from your local machine to upload\n",
        "uploaded = files.upload()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        },
        "id": "AVmCi2KEEaAZ",
        "outputId": "44ad2a22-3b74-4502-f716-273577b5a249"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-4dd83557-9854-4b1b-86d7-f83ca32cbdf0\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-4dd83557-9854-4b1b-86d7-f83ca32cbdf0\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving key.txt to key.txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "read the api key file ang get api key"
      ],
      "metadata": {
        "id": "QzeFGf7hE-Z3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "with open('key.txt', 'r') as f:\n",
        "  key = f.read()"
      ],
      "metadata": {
        "id": "pP0wy5-_FCxH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "download the data, nse data wont work but we will use ouw own file for next project anyway"
      ],
      "metadata": {
        "id": "kugQJyS2FgUr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Download stock market data (e.g., Apple Inc.)\n",
        "start_date = dt.datetime(2018, 1, 1)\n",
        "end_date = dt.datetime(2024, 2, 28)\n",
        "symbol = 'TSLA'  # Ticker symbol for Apple Inc.\n",
        "df = data.DataReader(symbol, \"av-daily\", start=datetime(2017, 2, 9),\n",
        "                    end=datetime(2024, 2, 26),\n",
        "                    api_key=key)\n",
        "\n"
      ],
      "metadata": {
        "id": "iRFn7uBTMuO2"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "plot the data"
      ],
      "metadata": {
        "id": "UHTZ5OghF3c_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "df.close.plot()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        },
        "id": "j0np2jE3F1_a",
        "outputId": "3a498fe3-07f2-41c0-93b8-efc5fc466f21"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Axes: >"
            ]
          },
          "metadata": {},
          "execution_count": 13
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "transform periodical timeseris data to stationary data by calculating % return"
      ],
      "metadata": {
        "id": "WMxeus-0GzG-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df['Open_pct'] = df['open'].pct_change()\n",
        "df['High_pct'] = df['high'].pct_change()\n",
        "df['Low_pct'] = df['low'].pct_change()\n",
        "df['Close_pct'] = df['close'].pct_change()\n",
        "df['volume_pct'] = df['volume'].pct_change()\n",
        "\n",
        "# Drop NaN values\n",
        "df.dropna(inplace=True)\n"
      ],
      "metadata": {
        "id": "fvbvGvFJFygp"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "print df and see columns (features)"
      ],
      "metadata": {
        "id": "u2yf3mRgGkj9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tabulate import tabulate\n",
        "print(tabulate(df.head(10), headers='keys', tablefmt='fancy_grid'))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-dQdLb_hGrdU",
        "outputId": "7d073b1f-3517-49a9-94da-aed87cdfa9db"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "╒════════════╤════════╤════════╤════════╤═════════╤═════════════╤═════════════╤══════════════╤══════════════╤══════════════╤══════════════╕\n",
            "│            │   open │   high │    low │   close │      volume │    Open_pct │     High_pct │      Low_pct │    Close_pct │   volume_pct │\n",
            "╞════════════╪════════╪════════╪════════╪═════════╪═════════════╪═════════════╪══════════════╪══════════════╪══════════════╪══════════════╡\n",
            "│ 2017-02-10 │ 269.79 │ 270.95 │ 266.11 │  269.23 │ 3.61974e+06 │  0.0132958  │ -0.000848145 │ -0.000150291 │  0.000111441 │   -0.537131  │\n",
            "├────────────┼────────┼────────┼────────┼─────────┼─────────────┼─────────────┼──────────────┼──────────────┼──────────────┼──────────────┤\n",
            "│ 2017-02-13 │ 270.74 │ 280.79 │ 270.51 │  280.6  │ 7.0296e+06  │  0.00352126 │  0.0363163   │  0.0165345   │  0.0422315   │    0.94202   │\n",
            "├────────────┼────────┼────────┼────────┼─────────┼─────────────┼─────────────┼──────────────┼──────────────┼──────────────┼──────────────┤\n",
            "│ 2017-02-14 │ 279.03 │ 287.39 │ 278.61 │  280.98 │ 7.34522e+06 │  0.0306198  │  0.0235055   │  0.0299434   │  0.00135424  │    0.0448985 │\n",
            "├────────────┼────────┼────────┼────────┼─────────┼─────────────┼─────────────┼──────────────┼──────────────┼──────────────┼──────────────┤\n",
            "│ 2017-02-15 │ 280    │ 282.24 │ 276.44 │  279.76 │ 4.94786e+06 │  0.00347633 │ -0.0179199   │ -0.00778867  │ -0.00434195  │   -0.326385  │\n",
            "├────────────┼────────┼────────┼────────┼─────────┼─────────────┼─────────────┼──────────────┼──────────────┼──────────────┼──────────────┤\n",
            "│ 2017-02-16 │ 277.6  │ 280    │ 268.5  │  268.95 │ 7.07732e+06 │ -0.00857143 │ -0.00793651  │ -0.0287223   │ -0.0386403   │    0.430382  │\n",
            "├────────────┼────────┼────────┼────────┼─────────┼─────────────┼─────────────┼──────────────┼──────────────┼──────────────┼──────────────┤\n",
            "│ 2017-02-17 │ 265.8  │ 272.89 │ 264.15 │  272.23 │ 6.25715e+06 │ -0.0425072  │ -0.0253929   │ -0.0162011   │  0.0121956   │   -0.115887  │\n",
            "├────────────┼────────┼────────┼────────┼─────────┼─────────────┼─────────────┼──────────────┼──────────────┼──────────────┼──────────────┤\n",
            "│ 2017-02-21 │ 275.45 │ 281.4  │ 274.01 │  277.39 │ 5.67675e+06 │  0.0363055  │  0.0311847   │  0.0373273   │  0.0189546   │   -0.0927582 │\n",
            "├────────────┼────────┼────────┼────────┼─────────┼─────────────┼─────────────┼──────────────┼──────────────┼──────────────┼──────────────┤\n",
            "│ 2017-02-22 │ 280.31 │ 283.45 │ 272.6  │  273.51 │ 8.75498e+06 │  0.0176439  │  0.007285    │ -0.0051458   │ -0.0139875   │    0.542252  │\n",
            "├────────────┼────────┼────────┼────────┼─────────┼─────────────┼─────────────┼──────────────┼──────────────┼──────────────┼──────────────┤\n",
            "│ 2017-02-23 │ 264    │ 264.66 │ 255.56 │  255.99 │ 1.49152e+07 │ -0.0581856  │ -0.0662904   │ -0.0625092   │ -0.0640562   │    0.703631  │\n",
            "├────────────┼────────┼────────┼────────┼─────────┼─────────────┼─────────────┼──────────────┼──────────────┼──────────────┼──────────────┤\n",
            "│ 2017-02-24 │ 252.66 │ 258.25 │ 250.2  │  257    │ 8.17163e+06 │ -0.0429545  │ -0.0242198   │ -0.0209735   │  0.00394547  │   -0.452129  │\n",
            "╘════════════╧════════╧════════╧════════╧═════════╧═════════════╧═════════════╧══════════════╧══════════════╧══════════════╧══════════════╛\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Give same scale to retun data so it's machine readable\n"
      ],
      "metadata": {
        "id": "GS3bI-IOHA8v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "scaler = StandardScaler()\n",
        "scaled_data = scaler.fit_transform(df[['Open_pct', 'High_pct', 'Low_pct', 'Close_pct', 'volume_pct']])\n"
      ],
      "metadata": {
        "id": "H9BU2AhMMzpD"
      },
      "execution_count": 52,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create sequences of length 10\n",
        "sequence_length = 2\n",
        "X, y = [], []\n",
        "for i in range(len(scaled_data) - sequence_length):\n",
        "    #i=1\n",
        "    X.append(scaled_data[i:i + sequence_length])\n",
        "    y.append(1 if df['close'].iloc[i + sequence_length] > df['close'].iloc[i + sequence_length - 1] else 0)\n",
        "\n",
        "X = np.array(X)\n",
        "y = np.array(y)\n"
      ],
      "metadata": {
        "id": "8rSI6BwkM2nk"
      },
      "execution_count": 53,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Split data into train and validation sets\n",
        "split_ratio = 0.7\n",
        "split_index = int(split_ratio * len(X))\n",
        "X_train, y_train = X[:split_index], y[:split_index]\n",
        "X_val, y_val = X[split_index:], y[split_index:]\n",
        "\n"
      ],
      "metadata": {
        "id": "j469VsEQM5el"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = Sequential()\n",
        "model.add(LSTM(64, return_sequences=True, input_shape=(sequence_length, 4), activation='relu'))\n",
        "model.add(LSTM(64, return_sequences=True, activation='relu'))  # Add an extra LSTM layer\n",
        "model.add(LSTM(64, return_sequences=True, activation='relu'))  # Add an extra LSTM layer\n",
        "model.add(LSTM(64, return_sequences=True, activation='relu'))  # Add an extra LSTM layer\n",
        "model.add(LSTM(64, return_sequences=True, activation='relu'))  # Add an extra LSTM layer\n",
        "model.add(LSTM(64))  # Last LSTM layer (no return_sequences)\n",
        "model.add(Dense(1, activation='sigmoid'))\n",
        "\n",
        "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n"
      ],
      "metadata": {
        "id": "3L_GaK9qM8UG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_loss_list = []\n",
        "val_loss_list = []\n",
        "\n",
        "# Custom training loop\n",
        "num_epochs = 500\n",
        "for epoch in range(num_epochs):\n",
        "    # Train the model\n",
        "    history = model.fit(X_train, y_train, epochs=1, batch_size=32, validation_data=(X_val, y_val))\n",
        "    train_loss = history.history['loss'][0]\n",
        "    train_loss_list.append(train_loss)\n",
        "\n",
        "    # Calculate validation loss (use your validation data)\n",
        "    # val_loss = model.evaluate(X_val, y_val, verbose=0)\n",
        "    # val_loss_list.append(val_loss)\n",
        "\n",
        "    # Update the plot\n",
        "    plt.clf()  # Clear the previous plot\n",
        "    plt.plot(train_loss_list, label='Training Loss')\n",
        "    # plt.plot(val_loss_list, label='Validation Loss')  # Uncomment for validation loss\n",
        "    plt.xlabel('Epochs')\n",
        "    plt.ylabel('Loss')\n",
        "    plt.title('Training and Validation Loss')\n",
        "    plt.legend()\n",
        "    plt.pause(0.01)  # Pause to update the plot\n",
        "\n",
        "# Show the final plot\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "9kdy38jDNAEI"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}