Monte Carlo Simulation for Time Series Probabilistic Forecasting

The Smart Home disruptor with 200% growth…

No, it’s not Ring or Nest—meet RYSE, the company redefining smart shade automation, and you can invest before its next major growth phase.

With $10M+ in revenue and distribution in 127 Best Buy locations, RYSE is rapidly emerging as a top acquisition target in the booming smart home industry, projected to grow 23% annually.

Its patented retrofit technology allows users to automate their window shades in minutes, controlled via smartphone or voice. With 200% year-over-year growth, demand is skyrocketing.

Now, RYSE’s public offering is live at just $1.90/share.

Find Out More

_{Past performance is not indicative of future results. Email may contain forward-looking statements. See US Offering for details. Informational purposes only.}

🚀 Your Investing Journey Just Got Better: Premium Subscriptions Are Here! 🚀

It’s been 4 months since we launched our premium subscription plans at GuruFinance Insights, and the results have been phenomenal! Now, we’re making it even better for you to take your investing game to the next level. Whether you’re just starting out or you’re a seasoned trader, our updated plans are designed to give you the tools, insights, and support you need to succeed.

Here’s what you’ll get as a premium member:

• Exclusive Trading Strategies: Unlock proven methods to maximize your returns.

• In-Depth Research Analysis: Stay ahead with insights from the latest market trends.

• Ad-Free Experience: Focus on what matters most—your investments.

• Monthly AMA Sessions: Get your questions answered by top industry experts.

• Coding Tutorials: Learn how to automate your trading strategies like a pro.

• Masterclasses & One-on-One Consultations: Elevate your skills with personalized guidance.

Our three tailored plans—Starter Investor, Pro Trader, and Elite Investor—are designed to fit your unique needs and goals. Whether you’re looking for foundational tools or advanced strategies, we’ve got you covered.

Don’t wait any longer to transform your investment strategy. The last 4 months have shown just how powerful these tools can be—now it’s your turn to experience the difference.

👉 Explore Premium Plans Now

Monte Carlo simulation is a computational technique used to model the behavior of complex systems. It generates random samples from probability distributions through the systems then analyzes the results. Monte Carlo simulation is applied across various fields including finance, engineering, physics, operations research, and all kinds of risk management. It is used extensively in time series to generate probabilistic predictions. We learn it here so later in the “Chapter 16: Amazon’s DeepAR for RNN/LSTM” and “Chapter 15: The Progression of Time Series Modeling Techniques,” we will see its practical use cases.

Let’s start with some fun facts. You may ask why it is called Monte Carlo. The name Monte Carlo is derived from the name of the city on a hill side of the mountain. Carlo is the Italian form of the name Charles, and Monte means mountain in Italian. Prince Charles III of Monaco ruled the principality from 1856 to 1889. The place is known for the Monte Carlo Casino.

It was 1940s, the time of World War II and the atomic bomb Manhattan project going on. Mathematicians Ulam and von Neumann were part of the Manhattan Project. They were interested in solving mathematical problems related to the behavior of neutrons in a nuclear chain reaction. However, the equations governing neutron diffusion were extremely complex and could not be solved analytically. To tackle these problems, Ulam and von Neumann realized that they could simulate neutron diffusion by using random numbers. They envisioned a simple game of solitaire played with cards at the Monte Carlo Casino. Therefore term Monte Carlo simulation was coined, and since then became a powerful computational technique.

Stay Informed, Without the Noise.

Your inbox is full of news. But how much of it is actually useful? The Daily Upside delivers sharp, insightful market analysis—without the fluff. Free, fast, and trusted by 1M+ investors. Stay ahead of the market in just a few minutes a day.

Subscribe today.

The process of a Monte Carlo simulation basically goes like this:

1. Define the model: First, you need to define the system or process you want to simulate including the equations and the parameters.

2. Generate random samples: Then you generate random samples from the fitted probability distributions.

3. Perform simulations: For each set of random samples, you run the model to simulate the behavior of the system.

4. Analyze results: After running a large number of simulations, you analyze the results to understand the behavior of the system.

Now let’s demonstrate how it works. I will apply it to simulate future stock prices with two distributions: the Gaussian distribution and the Student’s t-distribution. These two distributions are commonly used by quantitative analysts for stock market data. The Python code is available via this Github link for download.

Here we load Apple’s daily stock prices from 2020 to 2024.

import yfinance as yf
orig = yf.download(["AAPL"], start="2020-01-01", end="2024-12-31")
orig = orig[('Adj Close')]
orig.tail()

With the price series we can calculate the simple daily returns and plot in a histogram.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
returns = orig.pct_change()
last_price = orig[-1]
returns.hist(bins=100)

Let’s fit it with a normal distribution.

(1) Fit the returns as a standard normal distribution

We will first calculate the historical volatility of the stock. This is typically done by computing the standard deviation of the stock’s daily returns. We assume the future volatility will be similar to the historical volatility.

The histogram looks like a normal distribution centering at 0.0. For simplicity, we assume this distribution is a Gaussian distribution with mean =0 and its standard deviation. Below we derive the standard deviation which is also called the daily volatility. Then the daily return % for tomorrow is expected to be a random value from the Gaussian distribution:

daily_volatility = returns.std()
rtn = np.random.normal(0, daily_volatility)

The next day price is today’s price multiplying by (1+return %):

price = last_price * (1  + rtn)

The above are the basic financial formula for stock prices and returns. We are going to apply the MC simulation. To compute tomorrow’s price, we can randomly draw another return % to derive the day after tomorrow’s price. In this way we can derive a possible price path for the next, say, 200 days. This is just one of the possible price paths. We can repeat the same process to draw another price path. We will replicate this process 1,000 times to generate 1,000 price paths.

import warnings
warnings.simplefilter(action='ignore', category=pd.errors.PerformanceWarning)

num_simulations = 1000
num_days = 200
simulation_df = pd.DataFrame()
for x in range(num_simulations):
    count = 0    
    # The first price point
    price_series = []
    rtn = np.random.normal(0, daily_volatility)
    price = last_price * (1  + rtn)
    price_series.append(price)
    # Create each price path
    for g in range(num_days):
        rtn = np.random.normal(0, daily_volatility)
        price = price_series[g] * (1  + rtn)
        price_series.append(price)
    # Save all the possible price paths
    simulation_df[x] = price_series
fig = plt.figure()
plt.plot(simulation_df)
plt.xlabel('Number of days')
plt.ylabel('Possible prices')
plt.axhline(y = last_price, color = 'b', linestyle = '-')
plt.show()

The result is the following plot ready for analysis. The price starts at 179.66. Most of the price paths overlap with each other. The simulated price can be as high as $500 or as low as $100.

And suppose we want to know the “normal” price range that will happen 90% of the time (between 5% and 95%), we can use quantile to get the upper and the lower bounds. With that, we can assess the extreme prices outside the upper bound and lower bound.

upper = simulation_df.quantile(.95, axis=1)
lower = simulation_df.quantile(.05, axis=1)
stock_range = pd.concat([upper, lower], axis=1)

fig = plt.figure()
plt.plot(stock_range)
plt.xlabel('Number of days')
plt.ylabel('Possible prices')
plt.axhline(y = last_price, color = 'b', linestyle = '-')
plt.show()

Now let’s simulate with a Student’s t-distribution

Fit the returns as a Student’s t-distribution

Stock price returns are known to exhibit occasional extreme events. These extreme events locate the two sides of a distribution. A standard normal distribution expect 95% of the returns happening within two standard deviations and 5% outside the two standard deviations. If extreme events happen more often than 5%, the distribution will look “fatter”. This is what the statisticians called the fat tails because the distribution has fatter tails compared to the normal distribution. Because the distribution for stock price returns can exhibit fat tails, often quantitative analysts use the Student’s t-distribution to model stock price returns.

The Student’s t-distribution is characterized by three parameters:

• The degrees of freedom parameter: It represents the number of independent observations in a sample used to estimate a population parameter. As the degrees of freedom increase, the t-distribution approaches the shape of the standard normal distribution (bell-shaped curve). The range of degrees of freedom for a Student’s t-distribution is any positive real number greater than 0. When df is small, the tails of the t-distribution are heavier, resembling a more fat-tailed distribution.

• Scale: The scale parameter represents the spread or variability of the distribution. In the context of the t-distribution, the scale parameter is often the standard deviation of the population being sampled.

• Location: The location parameter represents the location or center of the distribution. It is the mean of the population being sampled.

Let’s fit the actual stock returns with a Student’s t-distribution.

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import t

returns = orig.pct_change()

# Number of samples per simulation
num_samples = 100

# distribution fitting
returns = returns[1::] # Drop the first element, which is "NA"
params = t.fit(returns[1::]) # fit with a student-t

# Generate random numbers from Student's t-distribution
results = t.rvs(df=params[0], loc=params[1], scale=params[2], size=1000)
# Generate random numbers from Student's t-distribution
results = t.rvs(df=params[0], loc=params[1], scale=params[2], size=1000)
print('degree of freedom = ', params[0])
print('loc = ', params[1])
print('scale = ', params[2])

The parameters are:

• degree of freedom = 3.735

• loc = 0.001

• scale = 0.014

We will use these parameters to project a Student-t distribution. Then we will plot the actual stock return distribution with the Student-t distribution.

returns.hist(bins=100,density=True, alpha=0.6, color='b', label='Actual returns distribution')

# Plot histogram of results
plt.hist(results, bins=100, density=True, alpha=0.6, color='g', label='Simulated Student/t distribution')

plt.xlabel('Value')
plt.ylabel('Density')
plt.title('Actual returns vs. Projections with a Student\'s t-distribution')
plt.legend(loc='center left')
plt.grid(True)
plt.show()

The actual returns and the projections are quite close:

Like before, we will simulate the price paths for the next 200 days.

import warnings
warnings.simplefilter(action='ignore', category=pd.errors.PerformanceWarning)

num_simulations = 1000
num_days = 200
simulation_student_t = pd.DataFrame()
for x in range(num_simulations):
    count = 0
    # The first price point
    price_series = []
    rtn = t.rvs(df=params[0], loc=params[1], scale=params[2], size=1)[0]
    price = last_price * (1  + rtn)
    price_series.append(price)
    # Create each price path
    for g in range(num_days):
        rtn = t.rvs(df=params[0], loc=params[1], scale=params[2], size=1)[0]
        price = price_series[g] * (1  + rtn)
        price_series.append(price)
    # Save all the possible price paths
    simulation_student_t[x] = price_series
fig = plt.figure()
plt.plot(simulation_student_t)
plt.xlabel('Number of days')
plt.ylabel('Possible prices')
plt.axhline(y = last_price, color = 'b', linestyle = '-')
plt.show()

The price paths are:

We can plot the upper bound at the 95% and the lower bound at the 5% confidence intervals for this Student-t Monte Carlo simulation:

upper = simulation_student_t.quantile(.95, axis=1)
lower = simulation_student_t.quantile(.05, axis=1)
stock_range = pd.concat([upper, lower], axis=1)

fig = plt.figure()
plt.plot(stock_range)
plt.xlabel('Number of days')
plt.ylabel('Possible prices')
plt.title('The upper 95% and lower 5%')
plt.axhline(y = last_price, color = 'b', linestyle = '-')
plt.show()

Conclusions

I hope this chapter helps you to conduct a Monte Carlo simulation. This chapter performs two distributions applications that are commonly used in stock market data. We define the model, generate random samples, perform simulations, then analyze the results. The simulation technique helps us to generate probabilistic predictions and understand the potential risks.