Upload 6 files

Montecarlo_Automated.ipynb

@@ -0,0 +1,1192 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "___\n",
+    "\n",
+    "<a href='https://github.com/eliasmelul/'> <img src='https://s3.us-east-2.amazonaws.com/wordontheamazon.com/NoMargin_NewLogo.png' style='width: 15em;' align='right' /></a>\n",
+    "# Finance with Python\n",
+    "### Monte Carlo Simulations for Stock Price Predictions\n",
+    "___\n",
+    "<h4 align=\"right\">by Elias Melul, Data Scientist </h4> \n",
+    "\n",
+    "___\n",
+    "\n",
+    "\n",
+    "\n",
+    "In this notebook, we introduce how to use Monte Carlo simulations for forecasting future stock prices.\n",
+    "\n",
+    "$$\n",
+    "{Price Today}={Price Yesterday * e^r}\n",
+    "$$\n",
+    "\n",
+    "* We know yesterday's price. \n",
+    "\n",
+    "* We want to predict today's price. \n",
+    "\n",
+    "* What we do not know is the rate of return, r, of the share price between yesterday and today. \n",
+    "\n",
+    "This is where the Monte Carlo simulation comes in! But first, how do we compute the return?\n",
+    "\n",
+    "### Brownian Motion\n",
+    "\n",
+    "Brownian motion will be the main driver for estimating the return. It is a stochastic process used for modeling random behavior over time. For simplicity, we will use regular brownian motion, instead of the Geometric Brownian Motion, which is more common and less questionable in stock pricing applications.\n",
+    "\n",
+    "**Brownian Motion** has two main main components:\n",
+    "1. Drift - the direction that rates of returns have had in the past. That is, the expected return of the stock.\n",
+    "$$\n",
+    "{Drift} = ({mean} - \\frac{1}{2} {Var})\n",
+    "$$\n",
+    "\n",
+    "    Why do we multiply the variance by 0.5? Because historical values are eroded in the future.\n",
+    "    \n",
+    "\n",
+    "2. Volatility -  random variable. This is the historical volatility multiplied by a random, standard normally distributed variable.\n",
+    "\n",
+    "$$\n",
+    "{Volatility} = {Std.Dev. * Z([Rand(0;1)])}\n",
+    "$$\n",
+    "\n",
+    "Therefore, our asset pricing equation ends up looking like this:\n",
+    "\n",
+    "$$\n",
+    "{Price Today}={Price Yesterday * e^{mean-\\frac{1}{2}{Var} + Std.Dev * Z([Rand(0;1)])}}\n",
+    "$$\n",
+    "\n",
+    "\n",
+    "\n",
+    "This technique will be used for every day into the future you want to predict, and for however many trials the monte carlo simulation will run!\n",
+    "\n",
+    "---\n",
+    "\n",
+    "First, import required libraries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 134,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "#from pandas_datareader import data as wb\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.stats import norm, gmean, cauchy\n",
+    "import seaborn as sns\n",
+    "from datetime import datetime\n",
+    "import os\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 135,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# set Variables\n",
+    "os.environ['API_KEY'] = 'XXXXXX'\n",
+    "tickers = ['AMP']  # Example tickers\n",
+    "days=180\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Import data for one or multiple stocks from a specified date until the last available data. Data source: yahoo finance.\n",
+    "\n",
+    "For this, it's better if we define a function that imports stock(s) daily data for any publicly traded company as defined by the user starting at a user-defined date until today. We will use the Adjusted Close price."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 136,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from alpha_vantage.timeseries import TimeSeries\n",
+    "import pandas as pd\n",
+    "from datetime import datetime\n",
+    "\n",
+    "# Function to import stock data using Alpha Vantage\n",
+    "def import_stock_data_alphavantage(tickers, api_key, start='2024-1-01', end=datetime.today().strftime('%Y-%m-%d')):\n",
+    "    data = pd.DataFrame()\n",
+    "    ts = TimeSeries(key=api_key, output_format='pandas')  # Initialize TimeSeries with your API key\n",
+    "    if isinstance(tickers, str):\n",
+    "        tickers = [tickers]  # Convert to list if only one ticker is provided\n",
+    "    for ticker in tickers:\n",
+    "        # Get the stock data\n",
+    "        df, meta_data = ts.get_daily_adjusted(ticker, outputsize='full')\n",
+    "        # Selecting only the '5. adjusted close' column and renaming it to the ticker\n",
+    "        df = df['5. adjusted close'].rename(ticker).to_frame()\n",
+    "        # Filter the data based on the start and end dates\n",
+    "        df = df[(df.index >= start) & (df.index <= end)]\n",
+    "        # If data is empty, initialize it with the current df\n",
+    "        if data.empty:\n",
+    "            data = df\n",
+    "        else:\n",
+    "            # If not empty, join the new df with the existing data\n",
+    "            data = data.join(df, how='outer')\n",
+    "    return data\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 137,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "               AMP\n",
+      "date              \n",
+      "2024-02-02  390.69\n",
+      "2024-02-01  386.02\n",
+      "2024-01-31  386.83\n",
+      "2024-01-30  393.55\n",
+      "2024-01-29  393.11\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Example usage\n",
+    "api_key = os.environ.get('API_KEY')\n",
+    "data = import_stock_data_alphavantage(tickers, api_key)\n",
+    "print(data.head())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then, we compute the logarithmic returns of the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def log_returns(data):\n",
+    "    return (np.log(1+data.pct_change()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 139,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "log_return = log_returns(data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We also create a function to compute the simple returns."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 140,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def simple_returns(data):\n",
+    "    return ((data/data.shift(1))-1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## CAPM and Sharpe\n",
+    "\n",
+    "Before we jump into Monte Carlo Simulations, we would like to report some statistics with it, including the Beta and Sharpe Ratio of the stock, compared to the _market portfolio_. To understand these metrics, we first must understand the underlying concepts of the _Capital Asset Pricing Model,_ starting with the _market portfolio_.\n",
+    "\n",
+    "* The market portfolio is the theoretical combination of all possible investments in the world. However, there is no such thing as a market portfolio. We approximate it with a stock market index. In our case, we use the S&P500, but you can specify any index you want to!\n",
+    "\n",
+    "* We also note that there is no such thing as a risk-free asset. We will use a 10-year US government bond yield of 2.5% instead.\n",
+    "\n",
+    "* The equity premium is the difference between the expected return of the market and the risk-free asset. This value is typically between 4.5 and 5.5%. We can use 5%.\n",
+    "\n",
+    "We use the _market portfolio_ to compute the Beta, the CAPM expected return, and the Sharpe Ratio of a stock.\n",
+    "1. **Beta**: measures the market risk that cannot be avoided through diversification. This is the relationship between the stock and the market portfolio. In other words, it is a measure of how much risk the investment will add to a portfolio that looks like the market.\n",
+    "##### $$ \n",
+    "\\beta_{i} = \\frac{\\sigma_{i,m}}{\\sigma_{m}^2}\n",
+    "$$\n",
+    "\n",
+    "        When beta = 0, it means that there's no relationship.\n",
+    "    \n",
+    "        When beta < 1, it means that the stock is defensive (less prone to high highs and low lows)\n",
+    "    \n",
+    "        When beta > 1, it means that the stock is aggresive (more prone to high highs and low lows)\n",
+    "    \n",
+    "    \n",
+    "2. **Expected Return CAPM**: calculates the expected return of a security adjusted to the risk taken. This equates to the return expected from taking the extra risk of purchasing this security.\n",
+    "##### $$\n",
+    "\\overline{r_{i}} = r_f + \\beta_{i}(\\overline{r_{m}} - r_f) \n",
+    "$$\n",
+    "\n",
+    "3. **Sharpe Ratio**: measures the performance of a security compared to a risk-free asset, after adjusting for its risk. This is the excess return per unit of risk of an investment.\n",
+    "##### $$\n",
+    "Sharpe = \\frac{\\overline{r_{i}} - r_f}{\\sigma_{i}}\n",
+    "$$\n",
+    "        When Sharpe > 1, GOOD risk-adjusted returns\n",
+    "    \n",
+    "        When Sharpe > 2, VERY GOOD risk-adjusted returns\n",
+    "    \n",
+    "        When Sharpe > 3, EXCELLENT risk-adjusted returns\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 141,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def market_data_combination(data, mark_ticker = \"SPY\", start='2022-1-1'):\n",
+    "    api_key = os.environ.get('API_KEY')\n",
+    "    market_data = import_stock_data_alphavantage(mark_ticker, api_key)\n",
+    "    market_rets = log_returns(market_data).dropna()\n",
+    "    ann_return = np.exp(market_rets.mean()*252).values-1\n",
+    "    data = data.merge(market_data, left_index=True, right_index=True)\n",
+    "    # Add debugging statements here\n",
+    "    print(\"Market data shape:\", market_data.shape)\n",
+    "    print(\"Number of non-NaN entries in market data:\", sum(~market_data.isna().values.flatten()))\n",
+    "    print(\"First few rows of market data:\\n\", market_data.head())\n",
+    "    return data, ann_return"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 142,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def beta_sharpe(data, mark_ticker = \"SPY\", start='2010-1-1', riskfree = 0.025):\n",
+    "    \n",
+    "    \"\"\"\n",
+    "    Input: \n",
+    "    1. data: dataframe of stock price data\n",
+    "    2. mark_ticker: ticker of the market data you want to compute CAPM metrics with (default is ^GSPC)\n",
+    "    3. start: data from which to download data (default Jan 1st 2010)\n",
+    "    4. riskfree: the assumed risk free yield (US 10 Year Bond is assumed: 2.5%)\n",
+    "    \n",
+    "    Output:\n",
+    "    1. Dataframe with CAPM metrics computed against specified market procy\n",
+    "    \"\"\"\n",
+    "    # Beta\n",
+    "    dd, mark_ret = market_data_combination(data, mark_ticker, start)\n",
+    "    print(\"printing dd\")\n",
+    "    print(dd.head())\n",
+    "    print(\"printing mark_ret\")\n",
+    "    print(mark_ret)\n",
+    "    log_ret = log_returns(dd)\n",
+    "    covar = log_ret.cov()*252\n",
+    "    covar = pd.DataFrame(covar.iloc[:-1,-1])\n",
+    "    mrk_var = log_ret.iloc[:,-1].var()*252\n",
+    "    beta = covar/mrk_var\n",
+    "    \n",
+    "    stdev_ret = pd.DataFrame(((log_ret.std()*250**0.5)[:-1]), columns=['STD'])\n",
+    "    beta = beta.merge(stdev_ret, left_index=True, right_index=True)\n",
+    "    \n",
+    "    # CAPM\n",
+    "    for i, row in beta.iterrows():\n",
+    "        beta.at[i,'CAPM'] = riskfree + (row[mark_ticker] * (mark_ret-riskfree))\n",
+    "    # Sharpe\n",
+    "    for i, row in beta.iterrows():\n",
+    "        beta.at[i,'Sharpe'] = ((row['CAPM']-riskfree)/(row['STD']))\n",
+    "    beta.rename(columns={\"SPY\":\"Beta\"}, inplace=True)\n",
+    "    \n",
+    "    return beta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 143,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "               AMP\n",
+      "date              \n",
+      "2024-02-02  390.69\n",
+      "2024-02-01  386.02\n",
+      "2024-01-31  386.83\n",
+      "2024-01-30  393.55\n",
+      "2024-01-29  393.11\n",
+      "2024-01-26  391.40\n",
+      "2024-01-25  391.38\n",
+      "2024-01-24  389.46\n",
+      "2024-01-23  387.80\n",
+      "2024-01-22  387.11\n",
+      "2024-01-19  381.67\n",
+      "2024-01-18  374.88\n",
+      "2024-01-17  372.06\n",
+      "2024-01-16  373.47\n",
+      "2024-01-12  376.40\n",
+      "2024-01-11  378.27\n",
+      "2024-01-10  377.99\n",
+      "2024-01-09  375.91\n",
+      "2024-01-08  384.44\n",
+      "2024-01-05  382.10\n",
+      "2024-01-04  379.04\n",
+      "2024-01-03  380.54\n",
+      "2024-01-02  379.03\n",
+      "Market data shape: (23, 1)\n",
+      "Number of non-NaN entries in market data: 23\n",
+      "First few rows of market data:\n",
+      "                SPY\n",
+      "date              \n",
+      "2024-02-02  494.35\n",
+      "2024-02-01  489.20\n",
+      "2024-01-31  482.88\n",
+      "2024-01-30  490.89\n",
+      "2024-01-29  491.27\n",
+      "printing dd\n",
+      "               AMP     SPY\n",
+      "date                      \n",
+      "2024-02-02  390.69  494.35\n",
+      "2024-02-01  386.02  489.20\n",
+      "2024-01-31  386.83  482.88\n",
+      "2024-01-30  393.55  490.89\n",
+      "2024-01-29  393.11  491.27\n",
+      "printing mark_ret\n",
+      "[-0.40200844]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Beta</th>\n",
+       "      <th>STD</th>\n",
+       "      <th>CAPM</th>\n",
+       "      <th>Sharpe</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>AMP</th>\n",
+       "      <td>0.776008</td>\n",
+       "      <td>0.147075</td>\n",
+       "      <td>-0.306362</td>\n",
+       "      <td>-2.253011</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "         Beta       STD      CAPM    Sharpe\n",
+       "AMP  0.776008  0.147075 -0.306362 -2.253011"
+      ]
+     },
+     "execution_count": 143,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "print(data)\n",
+    "beta_sharpe(data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Brownian Motion**\n",
+    "\n",
+    "Now that we have our returns, we can compute the brownian motion, as explained in the introduction.\n",
+    "1. Calculate the drift\n",
+    "2. Calculate the variance\n",
+    "3. Calculate the daily returns based on the drift and variance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 144,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def drift_calc(data, return_type='log'):\n",
+    "    try:\n",
+    "        if return_type == 'log':\n",
+    "            lr = log_returns(data)\n",
+    "        elif return_type == 'simple':\n",
+    "            lr = simple_returns(data)\n",
+    "        u = lr.mean()\n",
+    "        var = lr.var()\n",
+    "        drift = u - (0.5 * var)\n",
+    "        return drift.values\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error in drift_calc: {str(e)}\")\n",
+    "        print(\"Please check the input data and return type\")\n",
+    "        return None\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 145,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[-0.00142049]\n"
+     ]
+    }
+   ],
+   "source": [
+    "drift_calc(data)\n",
+    "print(drift_calc(data))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We calculated the drift above, but now, we must calculate the daily returns for the data. There are things to consider:\n",
+    "1. How many days into the future will we predict? (How many rows)\n",
+    "2. How many iterations of these predictions will we compute? (How many columns)\n",
+    "\n",
+    "This generates the daily returns (not prices!) for each day into the future for each iteration (simulation) based on a normal distribution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 146,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from scipy.stats import norm  # Add this import statement\n",
+    "# Other necessary imports...\n",
+    "\n",
+    "def daily_returns(data, days, iterations, return_type='log'):\n",
+    "    ft = drift_calc(data, return_type)\n",
+    "    if return_type == 'log':\n",
+    "        try:\n",
+    "            stv = log_returns(data).std().values\n",
+    "        except:\n",
+    "            stv = log_returns(data).std()\n",
+    "    elif return_type == 'simple':\n",
+    "        try:\n",
+    "            stv = simple_returns(data).std().values\n",
+    "        except:\n",
+    "            stv = simple_returns(data).std()\n",
+    "    \n",
+    "    # Oftentimes, we find that the distribution of returns is a variation of the normal distribution where it has a fat tail\n",
+    "    # This distribution is called cauchy distribution\n",
+    "    dr = np.exp(ft + stv * norm.ppf(np.random.rand(days, iterations)))\n",
+    "    return dr\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 147,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dr = daily_returns(data, 2, 3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Note**: This next function is used to calculate the probability of a stock having a higher price or higher returns than specified over the period defined. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 148,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def probs_find(predicted, higherthan, on = 'value'):\n",
+    "    \"\"\"\n",
+    "    This function calculated the probability of a stock being above a certain threshhold, which can be defined as a value (final stock price) or return rate (percentage change)\n",
+    "    Input: \n",
+    "    1. predicted: dataframe with all the predicted prices (days and simulations)\n",
+    "    2. higherthan: specified threshhold to which compute the probability (ex. 0 on return will compute the probability of at least breakeven)\n",
+    "    3. on: 'return' or 'value', the return of the stock or the final value of stock for every simulation over the time specified\n",
+    "    \"\"\"\n",
+    "    if on == 'return':\n",
+    "        predicted0 = predicted.iloc[0,0]\n",
+    "        predicted = predicted.iloc[-1]\n",
+    "        predList = list(predicted)\n",
+    "        over = [(i*100)/predicted0 for i in predList if ((i-predicted0)*100)/predicted0 >= higherthan]\n",
+    "        less = [(i*100)/predicted0 for i in predList if ((i-predicted0)*100)/predicted0 < higherthan]\n",
+    "    elif on == 'value':\n",
+    "        predicted = predicted.iloc[-1]\n",
+    "        predList = list(predicted)\n",
+    "        over = [i for i in predList if i >= higherthan]\n",
+    "        less = [i for i in predList if i < higherthan]\n",
+    "    else:\n",
+    "        print(\"'on' must be either value or return\")\n",
+    "    return (len(over)/(len(over)+len(less)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Example: We would like to find out the probability that our investment in PG will breakeven or make a profit over the course of a year (financial year is about 252 days). There are two ways we can do this:\n",
+    "1. Returns = 0\n",
+    "2. Final stock price = initial stock price ($44.05 - Jan 1st 2010, the first data point)\n",
+    "\n",
+    "So, with the simulation predicted values, we will predict said probabilities.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "First, however, we must run the simulation! How does it work?\n",
+    "\n",
+    "1. Calculate the daily returns for every day and every iteration (simulation) of the data. \n",
+    "2. Creates an equally large matrix of size [days x iteration] full of zeroes.\n",
+    "3. Input the last stock price value in the first row (day 0) of the \"empty\" matrix (part 2). This is our starting point.\n",
+    "4. Calculate \"today's price\" based on yesterday's multiplied by the daily return generated. That is, multiply the daily return generated for every simulation with the stock price calculated for the previous day (the previous row) for every simulation.\n",
+    "\n",
+    "Does that sounds familiar? The fourth step multiplies the daily returns with the price of the stock of the previous day!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 149,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "def simulate_mc(data, days, iterations, return_type='log', plot=True):\n",
+    "    # Generate daily returns\n",
+    "    returns = daily_returns(data, days, iterations, return_type)\n",
+    "    # Create empty matrix\n",
+    "    price_list = np.zeros_like(returns)\n",
+    "    # Put the last actual price in the first row of matrix. \n",
+    "    price_list[0] = data.iloc[-1]\n",
+    "    # Calculate the price of each day\n",
+    "    for t in range(1,days):\n",
+    "        price_list[t] = price_list[t-1]*returns[t]\n",
+    "    \n",
+    "    # Plot Option\n",
+    "    if plot == True:\n",
+    "        x = pd.DataFrame(price_list).iloc[-1]\n",
+    "        fig, ax = plt.subplots(1,2, figsize=(14,4))\n",
+    "        sns.distplot(x, ax=ax[0])\n",
+    "        sns.distplot(x, hist_kws={'cumulative':True},kde_kws={'cumulative':True},ax=ax[1])\n",
+    "        plt.xlabel(\"Stock Price\")\n",
+    "        plt.show()\n",
+    "    \n",
+    "    #CAPM and Sharpe Ratio\n",
+    "    \n",
+    "    # Printing information about stock\n",
+    "    try:\n",
+    "        [print(nam) for nam in data.columns]\n",
+    "    except:\n",
+    "        print(data.name)\n",
+    "    print(f\"Days: {days-1}\")\n",
+    "    print(f\"Expected Value: ${round(pd.DataFrame(price_list).iloc[-1].mean(),2)}\")\n",
+    "    print(f\"Return: {round(100*(pd.DataFrame(price_list).iloc[-1].mean()-price_list[0,1])/pd.DataFrame(price_list).iloc[-1].mean(),2)}%\")\n",
+    "    print(f\"Probability of Breakeven: {probs_find(pd.DataFrame(price_list),0, on='return')}\")\n",
+    "   \n",
+    "          \n",
+    "    return pd.DataFrame(price_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 150,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_5723/256993402.py:18: UserWarning: \n",
+      "\n",
+      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
+      "\n",
+      "Please adapt your code to use either `displot` (a figure-level function with\n",
+      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
+      "\n",
+      "For a guide to updating your code to use the new functions, please see\n",
+      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
+      "\n",
+      "  sns.distplot(x, ax=ax[0])\n",
+      "/tmp/ipykernel_5723/256993402.py:19: UserWarning: \n",
+      "\n",
+      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
+      "\n",
+      "Please adapt your code to use either `displot` (a figure-level function with\n",
+      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
+      "\n",
+      "For a guide to updating your code to use the new functions, please see\n",
+      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
+      "\n",
+      "  sns.distplot(x, hist_kws={'cumulative':True},kde_kws={'cumulative':True},ax=ax[1])\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x400 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "AMP\n",
+      "Days: 179\n",
+      "Expected Value: $295.29\n",
+      "Return: -28.36%\n",
+      "Probability of Breakeven: 0.021\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>0</th>\n",
+       "      <th>1</th>\n",
+       "      <th>2</th>\n",
+       "      <th>3</th>\n",
+       "      <th>4</th>\n",
+       "      <th>5</th>\n",
+       "      <th>6</th>\n",
+       "      <th>7</th>\n",
+       "      <th>8</th>\n",
+       "      <th>9</th>\n",
+       "      <th>...</th>\n",
+       "      <th>1990</th>\n",
+       "      <th>1991</th>\n",
+       "      <th>1992</th>\n",
+       "      <th>1993</th>\n",
+       "      <th>1994</th>\n",
+       "      <th>1995</th>\n",
+       "      <th>1996</th>\n",
+       "      <th>1997</th>\n",
+       "      <th>1998</th>\n",
+       "      <th>1999</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "      <td>379.030000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>379.352661</td>\n",
+       "      <td>381.714966</td>\n",
+       "      <td>383.375358</td>\n",
+       "      <td>374.618161</td>\n",
+       "      <td>379.056080</td>\n",
+       "      <td>383.724965</td>\n",
+       "      <td>379.268473</td>\n",
+       "      <td>383.107347</td>\n",
+       "      <td>375.761131</td>\n",
+       "      <td>376.028392</td>\n",
+       "      <td>...</td>\n",
+       "      <td>378.794027</td>\n",
+       "      <td>375.038490</td>\n",
+       "      <td>375.485313</td>\n",
+       "      <td>375.864464</td>\n",
+       "      <td>382.186543</td>\n",
+       "      <td>377.960955</td>\n",
+       "      <td>378.357218</td>\n",
+       "      <td>384.599065</td>\n",
+       "      <td>377.076425</td>\n",
+       "      <td>376.789847</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>383.591870</td>\n",
+       "      <td>383.667919</td>\n",
+       "      <td>387.326043</td>\n",
+       "      <td>378.040984</td>\n",
+       "      <td>383.788079</td>\n",
+       "      <td>384.552494</td>\n",
+       "      <td>380.759779</td>\n",
+       "      <td>380.522154</td>\n",
+       "      <td>375.154570</td>\n",
+       "      <td>374.085927</td>\n",
+       "      <td>...</td>\n",
+       "      <td>387.705626</td>\n",
+       "      <td>373.992699</td>\n",
+       "      <td>376.977980</td>\n",
+       "      <td>375.518888</td>\n",
+       "      <td>382.730319</td>\n",
+       "      <td>379.596358</td>\n",
+       "      <td>375.710396</td>\n",
+       "      <td>379.918507</td>\n",
+       "      <td>375.128224</td>\n",
+       "      <td>378.423115</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>386.108322</td>\n",
+       "      <td>387.878792</td>\n",
+       "      <td>384.256772</td>\n",
+       "      <td>375.464701</td>\n",
+       "      <td>387.219939</td>\n",
+       "      <td>381.711610</td>\n",
+       "      <td>381.759838</td>\n",
+       "      <td>377.722111</td>\n",
+       "      <td>380.351716</td>\n",
+       "      <td>369.994757</td>\n",
+       "      <td>...</td>\n",
+       "      <td>382.980634</td>\n",
+       "      <td>377.054784</td>\n",
+       "      <td>373.449616</td>\n",
+       "      <td>372.747890</td>\n",
+       "      <td>379.812307</td>\n",
+       "      <td>374.961612</td>\n",
+       "      <td>371.970980</td>\n",
+       "      <td>378.593563</td>\n",
+       "      <td>374.644340</td>\n",
+       "      <td>381.921425</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>381.631130</td>\n",
+       "      <td>392.071871</td>\n",
+       "      <td>386.789258</td>\n",
+       "      <td>379.043435</td>\n",
+       "      <td>388.119138</td>\n",
+       "      <td>384.337388</td>\n",
+       "      <td>382.796217</td>\n",
+       "      <td>378.511563</td>\n",
+       "      <td>382.213891</td>\n",
+       "      <td>369.667710</td>\n",
+       "      <td>...</td>\n",
+       "      <td>377.895425</td>\n",
+       "      <td>370.365979</td>\n",
+       "      <td>374.697049</td>\n",
+       "      <td>370.855179</td>\n",
+       "      <td>376.347085</td>\n",
+       "      <td>370.040956</td>\n",
+       "      <td>367.751955</td>\n",
+       "      <td>373.388293</td>\n",
+       "      <td>377.899273</td>\n",
+       "      <td>379.154510</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>175</th>\n",
+       "      <td>274.620651</td>\n",
+       "      <td>327.468959</td>\n",
+       "      <td>338.998329</td>\n",
+       "      <td>311.132089</td>\n",
+       "      <td>277.171998</td>\n",
+       "      <td>268.362211</td>\n",
+       "      <td>296.044323</td>\n",
+       "      <td>272.474672</td>\n",
+       "      <td>258.583479</td>\n",
+       "      <td>323.754294</td>\n",
+       "      <td>...</td>\n",
+       "      <td>308.143244</td>\n",
+       "      <td>306.289989</td>\n",
+       "      <td>293.509720</td>\n",
+       "      <td>238.018586</td>\n",
+       "      <td>241.767277</td>\n",
+       "      <td>276.028667</td>\n",
+       "      <td>331.820011</td>\n",
+       "      <td>274.102543</td>\n",
+       "      <td>318.014381</td>\n",
+       "      <td>367.952975</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>176</th>\n",
+       "      <td>273.823051</td>\n",
+       "      <td>330.329240</td>\n",
+       "      <td>340.157730</td>\n",
+       "      <td>315.772843</td>\n",
+       "      <td>276.109058</td>\n",
+       "      <td>271.104723</td>\n",
+       "      <td>290.589379</td>\n",
+       "      <td>271.241683</td>\n",
+       "      <td>259.441422</td>\n",
+       "      <td>322.390141</td>\n",
+       "      <td>...</td>\n",
+       "      <td>309.378225</td>\n",
+       "      <td>304.545964</td>\n",
+       "      <td>300.364879</td>\n",
+       "      <td>239.519264</td>\n",
+       "      <td>242.484682</td>\n",
+       "      <td>279.416244</td>\n",
+       "      <td>330.770579</td>\n",
+       "      <td>271.380431</td>\n",
+       "      <td>317.868825</td>\n",
+       "      <td>375.309240</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>177</th>\n",
+       "      <td>268.611234</td>\n",
+       "      <td>327.913665</td>\n",
+       "      <td>340.507277</td>\n",
+       "      <td>315.386937</td>\n",
+       "      <td>280.087126</td>\n",
+       "      <td>272.714697</td>\n",
+       "      <td>286.569191</td>\n",
+       "      <td>269.093063</td>\n",
+       "      <td>260.158056</td>\n",
+       "      <td>321.484201</td>\n",
+       "      <td>...</td>\n",
+       "      <td>311.814690</td>\n",
+       "      <td>309.325043</td>\n",
+       "      <td>295.015790</td>\n",
+       "      <td>240.915226</td>\n",
+       "      <td>241.481323</td>\n",
+       "      <td>279.862726</td>\n",
+       "      <td>328.342621</td>\n",
+       "      <td>267.904477</td>\n",
+       "      <td>316.983911</td>\n",
+       "      <td>377.162959</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>178</th>\n",
+       "      <td>267.943621</td>\n",
+       "      <td>326.330867</td>\n",
+       "      <td>336.213854</td>\n",
+       "      <td>313.826748</td>\n",
+       "      <td>278.087766</td>\n",
+       "      <td>266.557115</td>\n",
+       "      <td>284.299963</td>\n",
+       "      <td>267.645930</td>\n",
+       "      <td>258.882895</td>\n",
+       "      <td>318.415170</td>\n",
+       "      <td>...</td>\n",
+       "      <td>311.421097</td>\n",
+       "      <td>307.198771</td>\n",
+       "      <td>294.829539</td>\n",
+       "      <td>239.443694</td>\n",
+       "      <td>240.116965</td>\n",
+       "      <td>283.072914</td>\n",
+       "      <td>327.138140</td>\n",
+       "      <td>265.037441</td>\n",
+       "      <td>314.558325</td>\n",
+       "      <td>375.887249</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>179</th>\n",
+       "      <td>265.070193</td>\n",
+       "      <td>326.852844</td>\n",
+       "      <td>335.912955</td>\n",
+       "      <td>317.773837</td>\n",
+       "      <td>275.479935</td>\n",
+       "      <td>263.751964</td>\n",
+       "      <td>286.049375</td>\n",
+       "      <td>263.748028</td>\n",
+       "      <td>259.920448</td>\n",
+       "      <td>315.868492</td>\n",
+       "      <td>...</td>\n",
+       "      <td>309.732946</td>\n",
+       "      <td>307.898267</td>\n",
+       "      <td>298.888811</td>\n",
+       "      <td>238.543232</td>\n",
+       "      <td>244.912671</td>\n",
+       "      <td>282.958299</td>\n",
+       "      <td>326.508719</td>\n",
+       "      <td>263.808481</td>\n",
+       "      <td>314.730609</td>\n",
+       "      <td>380.917933</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>180 rows × 2000 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           0           1           2           3           4           5     \\\n",
+       "0    379.030000  379.030000  379.030000  379.030000  379.030000  379.030000   \n",
+       "1    379.352661  381.714966  383.375358  374.618161  379.056080  383.724965   \n",
+       "2    383.591870  383.667919  387.326043  378.040984  383.788079  384.552494   \n",
+       "3    386.108322  387.878792  384.256772  375.464701  387.219939  381.711610   \n",
+       "4    381.631130  392.071871  386.789258  379.043435  388.119138  384.337388   \n",
+       "..          ...         ...         ...         ...         ...         ...   \n",
+       "175  274.620651  327.468959  338.998329  311.132089  277.171998  268.362211   \n",
+       "176  273.823051  330.329240  340.157730  315.772843  276.109058  271.104723   \n",
+       "177  268.611234  327.913665  340.507277  315.386937  280.087126  272.714697   \n",
+       "178  267.943621  326.330867  336.213854  313.826748  278.087766  266.557115   \n",
+       "179  265.070193  326.852844  335.912955  317.773837  275.479935  263.751964   \n",
+       "\n",
+       "           6           7           8           9     ...        1990  \\\n",
+       "0    379.030000  379.030000  379.030000  379.030000  ...  379.030000   \n",
+       "1    379.268473  383.107347  375.761131  376.028392  ...  378.794027   \n",
+       "2    380.759779  380.522154  375.154570  374.085927  ...  387.705626   \n",
+       "3    381.759838  377.722111  380.351716  369.994757  ...  382.980634   \n",
+       "4    382.796217  378.511563  382.213891  369.667710  ...  377.895425   \n",
+       "..          ...         ...         ...         ...  ...         ...   \n",
+       "175  296.044323  272.474672  258.583479  323.754294  ...  308.143244   \n",
+       "176  290.589379  271.241683  259.441422  322.390141  ...  309.378225   \n",
+       "177  286.569191  269.093063  260.158056  321.484201  ...  311.814690   \n",
+       "178  284.299963  267.645930  258.882895  318.415170  ...  311.421097   \n",
+       "179  286.049375  263.748028  259.920448  315.868492  ...  309.732946   \n",
+       "\n",
+       "           1991        1992        1993        1994        1995        1996  \\\n",
+       "0    379.030000  379.030000  379.030000  379.030000  379.030000  379.030000   \n",
+       "1    375.038490  375.485313  375.864464  382.186543  377.960955  378.357218   \n",
+       "2    373.992699  376.977980  375.518888  382.730319  379.596358  375.710396   \n",
+       "3    377.054784  373.449616  372.747890  379.812307  374.961612  371.970980   \n",
+       "4    370.365979  374.697049  370.855179  376.347085  370.040956  367.751955   \n",
+       "..          ...         ...         ...         ...         ...         ...   \n",
+       "175  306.289989  293.509720  238.018586  241.767277  276.028667  331.820011   \n",
+       "176  304.545964  300.364879  239.519264  242.484682  279.416244  330.770579   \n",
+       "177  309.325043  295.015790  240.915226  241.481323  279.862726  328.342621   \n",
+       "178  307.198771  294.829539  239.443694  240.116965  283.072914  327.138140   \n",
+       "179  307.898267  298.888811  238.543232  244.912671  282.958299  326.508719   \n",
+       "\n",
+       "           1997        1998        1999  \n",
+       "0    379.030000  379.030000  379.030000  \n",
+       "1    384.599065  377.076425  376.789847  \n",
+       "2    379.918507  375.128224  378.423115  \n",
+       "3    378.593563  374.644340  381.921425  \n",
+       "4    373.388293  377.899273  379.154510  \n",
+       "..          ...         ...         ...  \n",
+       "175  274.102543  318.014381  367.952975  \n",
+       "176  271.380431  317.868825  375.309240  \n",
+       "177  267.904477  316.983911  377.162959  \n",
+       "178  265.037441  314.558325  375.887249  \n",
+       "179  263.808481  314.730609  380.917933  \n",
+       "\n",
+       "[180 rows x 2000 columns]"
+      ]
+     },
+     "execution_count": 150,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "simulate_mc(data, days, 2000, 'log')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, let's loop through all the stated securities and generate the visualizations and statistics that will help us understand the expected performance of a stock."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 151,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def monte_carlo(tickers, days_forecast, iterations, start_date = '2000-1-1', return_type = 'log', plotten=False):\n",
+    "    api_key = os.environ.get('API_KEY')\n",
+    "    data = import_stock_data_alphavantage(tickers, api_key)\n",
+    "    inform = beta_sharpe(data, mark_ticker=\"SPY\", start=start_date)\n",
+    "    simulatedDF = []\n",
+    "    for t in range(len(tickers)):\n",
+    "        y = simulate_mc(data.iloc[:,t], (days_forecast+1), iterations, return_type)\n",
+    "        if plotten == True:\n",
+    "            forplot = y.iloc[:,0:10]\n",
+    "            forplot.plot(figsize=(15,4))\n",
+    "        print(f\"Beta: {round(inform.iloc[t,inform.columns.get_loc('Beta')],2)}\")\n",
+    "        print(f\"Sharpe: {round(inform.iloc[t,inform.columns.get_loc('Sharpe')],2)}\") \n",
+    "        print(f\"CAPM Return: {round(100*inform.iloc[t,inform.columns.get_loc('CAPM')],2)}%\")\n",
+    "        y['ticker'] = tickers[t]\n",
+    "        cols = y.columns.tolist()\n",
+    "        cols = cols[-1:] + cols[:-1]\n",
+    "        y = y[cols]\n",
+    "        simulatedDF.append(y)\n",
+    "    simulatedDF = pd.concat(simulatedDF)\n",
+    "    return simulatedDF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 152,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Market data shape: (23, 1)\n",
+      "Number of non-NaN entries in market data: 23\n",
+      "First few rows of market data:\n",
+      "                SPY\n",
+      "date              \n",
+      "2024-02-02  494.35\n",
+      "2024-02-01  489.20\n",
+      "2024-01-31  482.88\n",
+      "2024-01-30  490.89\n",
+      "2024-01-29  491.27\n",
+      "printing dd\n",
+      "              GOOG    AAPL     SPY\n",
+      "date                              \n",
+      "2024-01-02  139.56  185.64  472.65\n",
+      "2024-01-03  140.36  184.25  468.79\n",
+      "2024-01-04  138.04  181.91  467.28\n",
+      "2024-01-05  137.39  181.18  467.92\n",
+      "2024-01-08  140.53  185.56  474.60\n",
+      "printing mark_ret\n",
+      "[-0.40200844]\n",
+      "Error in drift_calc: 'numpy.float64' object has no attribute 'values'\n",
+      "Please check the input data and return type\n"
+     ]
+    },
+    {
+     "ename": "TypeError",
+     "evalue": "unsupported operand type(s) for +: 'NoneType' and 'float'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[152], line 4\u001b[0m\n\u001b[1;32m      2\u001b[0m days_to_forecast\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m252\u001b[39m\n\u001b[1;32m      3\u001b[0m simulation_trials\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10000\u001b[39m\n\u001b[0;32m----> 4\u001b[0m ret_sim_df \u001b[38;5;241m=\u001b[39m \u001b[43mmonte_carlo\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mGOOG\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mAAPL\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdays_forecast\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mdays_to_forecast\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miterations\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msimulation_trials\u001b[49m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[43mstart_date\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mstart\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mplotten\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n",
+      "Cell \u001b[0;32mIn[151], line 7\u001b[0m, in \u001b[0;36mmonte_carlo\u001b[0;34m(tickers, days_forecast, iterations, start_date, return_type, plotten)\u001b[0m\n\u001b[1;32m      5\u001b[0m simulatedDF \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m t \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(tickers)):\n\u001b[0;32m----> 7\u001b[0m     y \u001b[38;5;241m=\u001b[39m \u001b[43msimulate_mc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43miloc\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43mt\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mdays_forecast\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miterations\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreturn_type\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      8\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m plotten \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m      9\u001b[0m         forplot \u001b[38;5;241m=\u001b[39m y\u001b[38;5;241m.\u001b[39miloc[:,\u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m10\u001b[39m]\n",
+      "Cell \u001b[0;32mIn[149], line 5\u001b[0m, in \u001b[0;36msimulate_mc\u001b[0;34m(data, days, iterations, return_type, plot)\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msimulate_mc\u001b[39m(data, days, iterations, return_type\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlog\u001b[39m\u001b[38;5;124m'\u001b[39m, plot\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;66;03m# Generate daily returns\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m     returns \u001b[38;5;241m=\u001b[39m \u001b[43mdaily_returns\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdays\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miterations\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreturn_type\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      6\u001b[0m     \u001b[38;5;66;03m# Create empty matrix\u001b[39;00m\n\u001b[1;32m      7\u001b[0m     price_list \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mzeros_like(returns)\n",
+      "Cell \u001b[0;32mIn[146], line 20\u001b[0m, in \u001b[0;36mdaily_returns\u001b[0;34m(data, days, iterations, return_type)\u001b[0m\n\u001b[1;32m     16\u001b[0m         stv \u001b[38;5;241m=\u001b[39m simple_returns(data)\u001b[38;5;241m.\u001b[39mstd()\n\u001b[1;32m     18\u001b[0m \u001b[38;5;66;03m# Oftentimes, we find that the distribution of returns is a variation of the normal distribution where it has a fat tail\u001b[39;00m\n\u001b[1;32m     19\u001b[0m \u001b[38;5;66;03m# This distribution is called cauchy distribution\u001b[39;00m\n\u001b[0;32m---> 20\u001b[0m dr \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mexp(\u001b[43mft\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mstv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mnorm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mppf\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrand\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdays\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miterations\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m     21\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dr\n",
+      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'NoneType' and 'float'"
+     ]
+    }
+   ],
+   "source": [
+    "start = \"2015-1-1\"\n",
+    "days_to_forecast= 252\n",
+    "simulation_trials= 10000\n",
+    "ret_sim_df = monte_carlo(['GOOG','AAPL'], days_forecast= days_to_forecast, iterations=simulation_trials,  start_date=start, plotten=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.12.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

README.md

@@ -1,13 +1 @@
----
-title: Montecarlo Automated
-emoji: 🌖
-colorFrom: purple
-colorTo: purple
-sdk: gradio
-sdk_version: 4.18.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# montecarlo-automated

app.py

@@ -0,0 +1,245 @@
+import gradio as gr
+import numpy as np
+import pandas as pd
+#from pandas_datareader import data as wb
+import matplotlib.pyplot as plt
+from scipy.stats import norm, gmean, cauchy
+import seaborn as sns
+from datetime import datetime
+import os
+import json
+
+#%matplotlib inline
+from alpha_vantage.timeseries import TimeSeries
+import pandas as pd
+from datetime import datetime
+
+# Function to import stock data using Alpha Vantage
+def import_stock_data_alphavantage(tickers, api_key, start='2024-1-01', end=datetime.today().strftime('%Y-%m-%d')):
+    data = pd.DataFrame()
+    ts = TimeSeries(key=api_key, output_format='pandas')  # Initialize TimeSeries with your API key
+    if isinstance(tickers, str):
+        tickers = [tickers]  # Convert to list if only one ticker is provided
+    for ticker in tickers:
+        # Get the stock data
+        df, meta_data = ts.get_daily_adjusted(ticker, outputsize='full')
+        # Selecting only the '5. adjusted close' column and renaming it to the ticker
+        df = df['5. adjusted close'].rename(ticker).to_frame()
+        # Filter the data based on the start and end dates
+        df = df[(df.index >= start) & (df.index <= end)]
+        # If data is empty, initialize it with the current df
+        if data.empty:
+            data = df
+        else:
+            # If not empty, join the new df with the existing data
+            data = data.join(df, how='outer')
+    return data
+
+
+def log_returns(data):
+    """
+    Calculate the log returns of a given dataset.
+
+    Parameters:
+    data (pandas.DataFrame): The dataset for which log returns are calculated.
+
+    Returns:
+    pandas.DataFrame: The log returns of the dataset.
+    """
+    return (np.log(1+data.pct_change()))
+
+
+def simple_returns(data):
+    """
+    Calculate the simple returns of a given dataset.
+
+    Parameters:
+    data (pandas.Series): The dataset for which to calculate the simple returns.
+
+    Returns:
+    pandas.Series: The simple returns of the dataset.
+    """
+    return ((data/data.shift(1))-1)
+
+
+def market_data_combination(data, mark_ticker = "SPY", start='2022-1-1'):
+    api_key = os.environ.get('ALPHAVANTAGE_API_KEY')
+    market_data = import_stock_data_alphavantage(mark_ticker, api_key)
+    market_rets = log_returns(market_data).dropna()
+    ann_return = np.exp(market_rets.mean()*252).values-1
+    data = data.merge(market_data, left_index=True, right_index=True)
+    # Add debugging statements here
+    print("Market data shape:", market_data.shape)
+    print("Number of non-NaN entries in market data:", sum(~market_data.isna().values.flatten()))
+    print("First few rows of market data:\n", market_data.head())
+    return data, ann_return
+
+def beta_sharpe(data, mark_ticker = "SPY", start='2010-1-1', riskfree = 0.025):
+    
+    """
+    Input: 
+    1. data: dataframe of stock price data
+    2. mark_ticker: ticker of the market data you want to compute CAPM metrics with (default is ^GSPC)
+    3. start: data from which to download data (default Jan 1st 2010)
+    4. riskfree: the assumed risk free yield (US 10 Year Bond is assumed: 2.5%)
+    
+    Output:
+    1. Dataframe with CAPM metrics computed against specified market procy
+    """
+    # Beta
+    dd, mark_ret = market_data_combination(data, mark_ticker, start)
+    print("printing dd")
+    print(dd.head())
+    print("printing mark_ret")
+    print(mark_ret)
+    log_ret = log_returns(dd)
+    covar = log_ret.cov()*252
+    covar = pd.DataFrame(covar.iloc[:-1,-1])
+    mrk_var = log_ret.iloc[:,-1].var()*252
+    beta = covar/mrk_var
+    
+    stdev_ret = pd.DataFrame(((log_ret.std()*250**0.5)[:-1]), columns=['STD'])
+    beta = beta.merge(stdev_ret, left_index=True, right_index=True)
+    
+    # CAPM
+    for i, row in beta.iterrows():
+        beta.at[i,'CAPM'] = riskfree + (row[mark_ticker] * (mark_ret-riskfree))
+    # Sharpe
+    for i, row in beta.iterrows():
+        beta.at[i,'Sharpe'] = ((row['CAPM']-riskfree)/(row['STD']))
+    beta.rename(columns={"SPY":"Beta"}, inplace=True)
+    
+    return beta
+
+def drift_calc(data, return_type='log'):
+    try:
+        if return_type == 'log':
+            lr = log_returns(data)
+        elif return_type == 'simple':
+            lr = simple_returns(data)
+        u = lr.mean()
+        var = lr.var()
+        drift = u - (0.5 * var)
+        return drift.values
+    except Exception as e:
+        print(f"Error in drift_calc: {str(e)}")
+        print("Please check the input data and return type")
+        return None
+
+def daily_returns(data, days, iterations, return_type='log'):
+    ft = drift_calc(data, return_type)
+    if return_type == 'log':
+        try:
+            stv = log_returns(data).std().values
+        except:
+            stv = log_returns(data).std()
+    elif return_type == 'simple':
+        try:
+            stv = simple_returns(data).std().values
+        except:
+            stv = simple_returns(data).std()
+    
+    # Oftentimes, we find that the distribution of returns is a variation of the normal distribution where it has a fat tail
+    # This distribution is called cauchy distribution
+    dr = np.exp(ft + stv * norm.ppf(np.random.rand(days, iterations)))
+    return dr
+
+def probs_find(predicted, higherthan, on = 'value'):
+    """
+    This function calculated the probability of a stock being above a certain threshhold, which can be defined as a value (final stock price) or return rate (percentage change)
+    Input: 
+    1. predicted: dataframe with all the predicted prices (days and simulations)
+    2. higherthan: specified threshhold to which compute the probability (ex. 0 on return will compute the probability of at least breakeven)
+    3. on: 'return' or 'value', the return of the stock or the final value of stock for every simulation over the time specified
+    """
+    if on == 'return':
+        predicted0 = predicted.iloc[0,0]
+        predicted = predicted.iloc[-1]
+        predList = list(predicted)
+        over = [(i*100)/predicted0 for i in predList if ((i-predicted0)*100)/predicted0 >= higherthan]
+        less = [(i*100)/predicted0 for i in predList if ((i-predicted0)*100)/predicted0 < higherthan]
+    elif on == 'value':
+        predicted = predicted.iloc[-1]
+        predList = list(predicted)
+        over = [i for i in predList if i >= higherthan]
+        less = [i for i in predList if i < higherthan]
+    else:
+        print("'on' must be either value or return")
+    return (len(over)/(len(over)+len(less)))
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+def simulate_mc(data, days, iterations, return_type='log', plot=True):
+    # Generate daily returns
+    returns = daily_returns(data, days, iterations, return_type)
+    # Create empty matrix
+    price_list = np.zeros_like(returns)
+    # Put the last actual price in the first row of matrix. 
+    price_list[0] = data.iloc[-1]
+    # Calculate the price of each day
+    for t in range(1,days):
+        price_list[t] = price_list[t-1]*returns[t]
+    
+    # Plot Option
+    if plot == True:
+        x = pd.DataFrame(price_list).iloc[-1]
+        fig, ax = plt.subplots(1,2, figsize=(14,4))
+        sns.distplot(x, ax=ax[0])
+        sns.distplot(x, hist_kws={'cumulative':True},kde_kws={'cumulative':True},ax=ax[1])
+        plt.xlabel("Stock Price")
+        plt.savefig('stock_price_distribution.png')
+        plt.show()
+    
+    #CAPM and Sharpe Ratio
+    
+    # Printing information about stock
+    try:
+        [print(nam) for nam in data.columns]
+    except:
+        print(data.name)
+    print(f"Days: {days-1}")
+    print(f"Expected Value: ${round(pd.DataFrame(price_list).iloc[-1].mean(),2)}")
+    print(f"Return: {round(100*(pd.DataFrame(price_list).iloc[-1].mean()-price_list[0,1])/pd.DataFrame(price_list).iloc[-1].mean(),2)}%")
+    print(f"Probability of Breakeven: {probs_find(pd.DataFrame(price_list),0, on='return')}")
+    output = {
+        "Days": days-1,
+        "Expected Value": round(pd.DataFrame(price_list).iloc[-1].mean(), 2),
+        "Return": round(100*(pd.DataFrame(price_list).iloc[-1].mean()-price_list[0,1])/pd.DataFrame(price_list).iloc[-1].mean(), 2),
+        "Probability of Breakeven": probs_find(pd.DataFrame(price_list), 0, on='return')
+    }
+    return (json.dumps(output))
+   
+          
+   # return pd.DataFrame(price_list)
+
+# set Variables
+def get_stock_data(tickers, days):
+    api_key = os.getenv('ALPHAVANTAGE_API_KEY')
+    # Placeholder -  This is where you'd fetch and process the actual stock data 
+    # using libraries like pandas-datareader, yfinance, etc.
+    data = import_stock_data_alphavantage(tickers, api_key)
+    print(data.head())
+    log_return = log_returns(data)
+    print(data)
+    beta_sharpe(data)
+    drift_calc(data)
+    print(drift_calc(data))
+    dr = daily_returns(data, 2, 3)
+    item = simulate_mc(data, days, 2000, 'log')
+    print(item)
+    return {item}
+
+
+
+# Create Gradio interface elements
+ticker_input = gr.Textbox(lines=1, placeholder="Enter tickers separated by commas (e.g., AAPL, TSLA)")
+days_input = gr.Number(value=180, label="Number of Days")
+
+iface = gr.Interface(
+    fn=get_stock_data, 
+    inputs=[ticker_input, days_input], 
+    outputs="text",
+    title="Stock Data Analyzer"
+)
+
+iface.launch(share=True)

client-test.py

@@ -0,0 +1,9 @@
+from gradio_client import Client
+
+client = Client("http://127.0.0.1:7866/")
+result = client.predict(
+		"UI",	# str  in 'tickers' Textbox component
+		14,	# float  in 'Number of Days' Number component
+		api_name="/predict"
+)
+print(result)

requirements.txt

@@ -0,0 +1,10 @@
+numpy
+pandas
+pandas_datareader
+matplotlib
+scipy
+seaborn
+alpha_vantage
+gradio
+gradio_client
+boto3

testimage-push.py

@@ -0,0 +1,23 @@
+import boto3
+import os
+
+# Make aws_access_key_id and aws_secret_access_key as environment variables
+aws_access_key_id_env = os.environ['AWS_ACCESS_KEY_ID']
+aws_secret_access_key_env = os.environ['AWS_SECRET_ACCESS_KEY']
+
+
+# Let's use S3
+s3 = boto3.resource(
+    service_name='s3',
+    aws_access_key_id=aws_access_key_id_env,
+    aws_secret_access_key=aws_secret_access_key_env,
+    endpoint_url='https://s3.tebi.io'
+)
+
+# Print out bucket names
+for bucket in s3.buckets.all():
+    print(bucket.name)
+
+# Upload a new file
+data = open('stock_price_distribution.png', 'rb')
+s3.Bucket('montecarlo-automated-images').put_object(Key='stock_price_distribution.png', Body=data)