{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"___\n",
"\n",
"\n",
"# Finance with Python\n",
"### Monte Carlo Simulations for Stock Price Predictions\n",
"___\n",
"
by Elias Melul, Data Scientist
\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": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Beta
\n",
"
STD
\n",
"
CAPM
\n",
"
Sharpe
\n",
"
\n",
" \n",
" \n",
"
\n",
"
AMP
\n",
"
0.776008
\n",
"
0.147075
\n",
"
-0.306362
\n",
"
-2.253011
\n",
"
\n",
" \n",
"
\n",
"
"
],
"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": [
"
