Momentum_stock_model_downloading_data_combined.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qNRS0qK13jAx"
      },
      "outputs": [],
      "source": [
        "# Import necessary libraries\n",
        "from google.colab import files\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 1: Upload the Excel file from local system\n",
        "uploaded = files.upload()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "id": "scYWuhYr4p-0",
        "outputId": "4a1cb130-9249-47f3-ee97-786b4b5b5384"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-f0b71a71-bd17-480c-819b-2333c82cbc1e\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-f0b71a71-bd17-480c-819b-2333c82cbc1e\">\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 Stocks-M.xlsx to Stocks-M.xlsx\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 2: Load the Excel file\n",
        "file_path = list(uploaded.keys())[0]  # Automatically get the uploaded file name\n",
        "xls = pd.ExcelFile(file_path)"
      ],
      "metadata": {
        "id": "3l7hS8By4qCq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 3: Initialize dictionaries to store value and momentum data for each ticker\n",
        "value_data = {}\n",
        "momentum_data = {}\n",
        "\n",
        "# Identify tickers and load corresponding sheets\n",
        "for sheet_name in xls.sheet_names:\n",
        "    ticker = sheet_name.split('-')[0]\n",
        "    if '-V' in sheet_name:\n",
        "        value_data[ticker] = xls.parse(sheet_name)\n",
        "    elif '-M' in sheet_name:\n",
        "        momentum_data[ticker] = xls.parse(sheet_name)"
      ],
      "metadata": {
        "id": "eqMoqR084qF2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_momentum_indicators(momentum_df):\n",
        "    # Assuming 'Close Price' is in momentum_data[ticker]\n",
        "    momentum_df['52-Week High'] = momentum_df['Close'].rolling(window=252).max()\n",
        "    momentum_df['10-Year Return'] = momentum_df['Close'].pct_change(periods=10*252).mean()\n",
        "    momentum_df['5-Year Return'] = momentum_df['Close'].pct_change(periods=5*252).mean()\n",
        "    momentum_df['3-Year Return'] = momentum_df['Close'].pct_change(periods=3*252).mean()\n",
        "    momentum_df['12-Month Return'] = momentum_df['Close'].pct_change(periods=252)\n",
        "    momentum_df['6-Month Return'] = momentum_df['Close'].pct_change(periods=126)\n",
        "    momentum_df['50-Day MA'] = momentum_df['Close'].rolling(window=50).mean()\n",
        "    momentum_df['200-Day MA'] = momentum_df['Close'].rolling(window=200).mean()\n",
        "    momentum_df['Acceleration Rate'] = momentum_df['50-Day MA'] / momentum_df['200-Day MA']\n",
        "    return momentum_df[['52-Week High', '10-Year Return', '5-Year Return', '3-Year Return', '12-Month Return', '6-Month Return', 'Acceleration Rate']]"
      ],
      "metadata": {
        "id": "Px_JfEqJ4qJO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def download_momentum_indicators(momentum_data):\n",
        "     with ExcelWriter('momentum_indicators.xlsx') as writer:\n",
        "         for ticker in momentum_data.keys():\n",
        "             momentum_indicators = calculate_momentum_indicators(momentum_data[ticker])\n",
        "             momentum_indicators.to_excel(writer, sheet_name=ticker, index=False) # Set index=False to avoid writing index"
      ],
      "metadata": {
        "id": "cdxG32oI0NfO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def form_portfolios(momentum_data):\n",
        "    portfolios = {'momentum': []}\n",
        "    momentum_scores = [] # Initialize a list to store momentum scores\n",
        "    tickers_list = [] # Initialize a list to store tickers\n",
        "\n",
        "    for ticker in momentum_data.keys():\n",
        "        momentum_indicators = calculate_momentum_indicators(momentum_data[ticker])\n",
        "\n",
        "        # Calculate a single momentum score (e.g., average of indicators)\n",
        "        momentum_score = momentum_indicators.mean(axis=1).mean() # Example using mean\n",
        "        momentum_scores.append(momentum_score)\n",
        "        tickers_list.append(ticker)\n",
        "        portfolios['momentum'].append((ticker, momentum_score))\n",
        "\n",
        "\n",
        "    # Form quintiles using pd.qcut\n",
        "    quintiles = pd.qcut(momentum_scores, 5, labels=False)\n",
        "    quintile_data = pd.DataFrame({'Ticker': tickers_list, 'Quintile': quintiles})\n",
        "\n",
        "    return quintile_data # Or return whatever data structure is needed"
      ],
      "metadata": {
        "id": "zsOUNAgN4qMf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 6: Evaluate Portfolio Performance\n",
        "def evaluate_portfolio_performance(portfolio):\n",
        "    # Placeholder for performance evaluation metrics\n",
        "    performance_metrics = {\n",
        "        'return': [],\n",
        "        'sharpe_ratio': [],\n",
        "        'jensen_alpha': []\n",
        "    }\n",
        "    # Iterate over the rows of the DataFrame using iterrows()\n",
        "    for index, row in portfolio.iterrows():\n",
        "        ticker = row['Ticker']  # Access the 'Ticker' column\n",
        "        # score = row['Score']  # Access other columns if needed\n",
        "        # Assume we have returns data, calculate metrics\n",
        "        returns = momentum_data[ticker]['Close'].pct_change()\n",
        "        mean_return = returns.mean() * 252\n",
        "        std_dev = returns.std() * np.sqrt(252)\n",
        "        sharpe_ratio = mean_return / std_dev\n",
        "        # Jensen alpha can be calculated using CAPM if benchmark data is available\n",
        "        # Placeholder: jensen_alpha = calculate_jensen_alpha(returns, benchmark_returns)\n",
        "\n",
        "        performance_metrics['return'].append(mean_return)\n",
        "        performance_metrics['sharpe_ratio'].append(sharpe_ratio)\n",
        "        # performance_metrics['jensen_alpha'].append(jensen_alpha)\n",
        "\n",
        "    return performance_metrics\n",
        "\n"
      ],
      "metadata": {
        "id": "ck03bTLy4qPv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Step 7: Run the full analysis\n",
        "momentum_portfolio = form_portfolios(momentum_data)\n",
        "momentum_performance = evaluate_portfolio_performance(momentum_portfolio)\n",
        "\n",
        "# Extract ticker symbols and quintiles from momentum_portfolio\n",
        "tickers = momentum_portfolio['Ticker'].tolist()\n",
        "quintiles = momentum_portfolio['Quintile'].tolist() # Extract quintiles\n",
        "\n",
        "# Prepare data for display in tabular form\n",
        "momentum_performance_df = pd.DataFrame({\n",
        "    'Ticker': tickers,  # Use the tickers list\n",
        "    'Quintile': quintiles,  # Add quintiles to the DataFrame\n",
        "    'Return': momentum_performance['return'],\n",
        "    'Sharpe Ratio': momentum_performance['sharpe_ratio']\n",
        "})\n",
        "\n",
        "# Sort the DataFrame by 'Quintile' in descending order\n",
        "momentum_performance_df = momentum_performance_df.sort_values(by='Quintile', ascending=False)\n",
        "\n",
        "# Display the results in a DataFrame format\n",
        "print(\"Momentum Portfolio Performance:\")\n",
        "print(momentum_performance_df)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FTu5768b4qaO",
        "outputId": "acf03d56-8bd1-40b5-d093-404c9ce8deb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Momentum Portfolio Performance:\n",
            "   Ticker  Quintile    Return  Sharpe Ratio\n",
            "19   NVDA         4  0.641028      1.372286\n",
            "18   NFLX         4  0.348448      0.797435\n",
            "16   META         4  0.291693      0.777515\n",
            "9    BIIB         4  0.058729      0.140404\n",
            "5     JNJ         3  0.071299      0.401454\n",
            "7     PEP         3  0.084786      0.467177\n",
            "11   BIDU         3  0.047868      0.108288\n",
            "12   MSFT         3  0.264903      1.001170\n",
            "17   AMZN         2  0.276087      0.844366\n",
            "6      PG         2  0.088436      0.491030\n",
            "15    AMD         2  0.496729      0.869789\n",
            "14   AAPL         2  0.273614      0.980988\n",
            "13  GOOGL         1  0.221045      0.793290\n",
            "10    AEP         1  0.095094      0.463482\n",
            "1      ED         1  0.078907      0.386259\n",
            "2     DUK         1  0.070355      0.349660\n",
            "8      KO         0  0.066451      0.378556\n",
            "4      CL         0  0.059225      0.320056\n",
            "3     GIS         0  0.052904      0.258553\n",
            "0      SO         0  0.094594      0.446635\n"
          ]
        }
      ]
    }
  ]
}