Back

# How to build and visualise a Monte Carlo simulation with Python and Plotly

January 6, 2023 12 minute read

Contents

## What are Monte Carlo simulations?

Monte Carlo simulations are used to model the probabilities of different outcomes where those outcomes are hard to predict due to random variables. The Law of large numbers states that as a sample size grows, its mean gets closer to the average of the whole population. This is due to the sample being more representative of the population as the sample become larger. In other words, with a Monte Carlo simulation the goal is to simulate the collection of all or many possible paths (using random sampling) in order to find the possibilities and the most likely or theoretical solution.

In summary:

• A Monte Carlo simulation is a model used to predict the probability of a variety of outcomes when the potential for random variables is present.
• Monte Carlo simulations help to explain the impact of risk and uncertainty in prediction and forecasting models.
• A Monte Carlo simulation requires assigning multiple values to an uncertain variable to achieve multiple results and then averaging the results to obtain an estimate.
• A Monte Carlo model is a stochastic model, meaning that due to randomness the results may differ each time, as opposed to a deterministic model where given the same inputs you'll get the same result every time.

## A quick example to illustrate

Monte Carlo simulations are named after the Monte Carlo casino in Monaco, so let's ask a casino based question.

"If we always pick red at roulette, how often would we win?"

The roulette wheel has 18 red slots, 18 black slots, and 1 green slot for a total of 37 slots.

roulette.py
``````import random

def play_roulette():
total_slots = 37
red_probability   = (18 / total_slots) * 100
black_probability = (18 / total_slots) * 100
green_probability = (1 / total_slots) * 100

possible_outcomes = ["red", "black", "green"]
probabilities = [red_probability, black_probability, green_probability]

outcome = random.choices(
possible_outcomes,
weights=probabilities,
k=1
)

return outcome

def perform_simulation(n_times=1000, choice="red"):
results = { "red": 0, "black": 0, "green": 0 }

for i in range(n_times):
outcome = play_roulette()
results[outcome] += 1

win_percentage = results[choice] / n_times

return results, win_percentage

if __name__ == "__main__":
results, win_percentage = perform_simulation(n_times=1000000,
choice="red")

print(results)
print(win_percentage)
``````
TERMINAL
Python

So after 1 million simulations, we can say we win just less than half of the time with a 48.71% probability. We've proven that the extra green pocket gives the house an edge over the long run.

## Building the Monte Carlo model with Python

Now we have an idea of what a Monte Carlo simulation is and have seen a short example, we can build a more complex model. The challenge I have set here is to recreate an awesome Monte Carlo retirement simulation from engaging-data.com using Python and Plotly. After playing around with this calculator I wondered how this could be re-created in Python with a few individual touches. I got quite close and there's lots to learn from the code.

The question this time is "If I invest a set amount for a number of years, how much might I have?"

All of the code for this model can be found on GitHub.

model.py
``````"""
Monte Carlo model to simulate the growth
of an investment portfolio over time.
"""
import numpy as np
from helpers import (
get_random_returns,
get_confidence_levels,
get_yearly_percentiles)

from plots import (
plot_histogram,
plot_yearly_percentiles)

def perform_simulation(inputs: dict):
"""
Performs a simulation to find out how much
the pot is worth in £ after years of growth.

Returns:
pot (float)     - the final amount at the end
history (list)  - the yearly history of results
[10000, 11000, 12000, ...]

"""
years = inputs['end_age'] - inputs['start_age']
pot = inputs['starting_pot']
returns = get_random_returns(years=years)
mean_return = (np.mean(returns) - 1) * 100

history = []

for i in range(years):
annual_return = returns[i]
pot *= annual_return
pot += inputs['annual_contributions']
history.append(int(pot))

return pot, history, mean_return

def perform_monte_carlo(inputs: dict, n: int = 1000):
pot_sizes = []
results = []
mean_returns = []

for i in range(n):
final_amount, history, mean_return = perform_simulation(inputs)
pot_sizes.append(final_amount)
results.append(history)
mean_returns.append(mean_return)

lower_confidence, upper_confidence = get_confidence_levels(pot_sizes)

print('Monte carlo model done :)', end='\n')
print('Plots saved to /outputs folder')
print('Mean return across all simulations: ', end='')
print(f'{round(np.mean(mean_returns), 1)}%')

return {
'pot_sizes': pot_sizes,
'results': results,
'yearly_percentiles': get_yearly_percentiles(results, inputs),
'lower_confidence': lower_confidence,
'upper_confidence': upper_confidence,
'mean_returns': mean_returns
}

if __name__ == "__main__":
inputs = {
'start_age': 20,
'end_age': 65,
'starting_pot': 5000,
'annual_contributions': 500 * 12,
'target_amount': 300000,
'n_simulations': 10000
}

mc = perform_monte_carlo(inputs,
n=inputs['n_simulations'])

plot_histogram(mc['pot_sizes'],
mc['upper_confidence'],
mc['lower_confidence'])

plot_yearly_percentiles(inputs=inputs,
df=mc['yearly_percentiles'])
``````

This model takes a dictionary 'inputs' which you can change to adapt the simulation. The 'perform_monte_carlo' function carries out a given number of simulations and returns the final 'pot_sizes' with other useful information like the history and mean returns of each simulation, the yearly percentiles, alongside upper and lower confidence intervals.

For this example our starting age is 20 and end age is 65. We start with £5,000 and our annual contributions are £6,000 (or £500 per month) and we're aiming for a £300,000 pot! We will run this simulation 10,000 times. You might be thinking, how do we simulate the randomness of what our returns might be each year?

A quick Google search tells us that the historic annual average return of the S&P500 is 10% per year. Sorry but I'm much more pessimistic and expect lower. I have modelled a range of returns and assigned them probability weights in the file helpers.py below. This means I've assumed low returns are more likely, but there is also a chance of higher returns, or negative returns. Nobody knows what the markets will do, and that's why randomness will help us with this uncertainty and view the outcomes of many simulations.

helpers.py
``````import random
import numpy as np
import pandas as pd

def get_random_returns(years: int):
"""
Generates a list of random return percentages
for the length of years required.
"""
random_returns = []

for i in range(years):
high_negative_returns = (random.randint(-20, -8) / 1000) + 1
low_negative_returns = (random.randint(-7, -1) / 1000) + 1
low_returns = (random.randint(0, 4) / 100) + 1
medium_returns = (random.randint(5, 9) / 100) + 1
high_returns = (random.randint(10, 20) / 100) + 1

possible_returns = [        # Weights
high_negative_returns,  # 5  % chance
low_negative_returns,   # 25 % chance
low_returns,            # 40 % chance
medium_returns,         # 25 % chance
high_returns            # 5  % chance
]

random_return = random.choices(
possible_returns,
weights=(5, 25, 40, 25, 5),
k=1
)

random_returns.append(
random_return
)

return random_returns

def get_confidence_levels(pot_sizes):
upper_confidence = round(np.quantile(pot_sizes, 0.975), 2)
lower_confidence = round(np.quantile(pot_sizes, 0.025), 2)

return lower_confidence, upper_confidence

def get_yearly_percentiles(results, inputs) -> pd.DataFrame:
"""
Finds the percentiles for each year.
"""
results_rotated = list(zip(*results[::-1]))

year = []
age = []
ninetieth_percentile = []
seventy_fifth_percentile = []
median = []
twenty_fifth_percentile = []
tenth_percentile = []

for i, year_results in enumerate(results_rotated):
new_age = (inputs['start_age'] + 1) + i
ninetieth_percentile_value = np.percentile(year_results, 90)
seventy_fifth_percentile_value = np.percentile(year_results, 75)
median_value = np.median(year_results)
twenty_fifth_percentile_value = np.percentile(year_results, 25)
tenth_percentile_value = np.percentile(year_results, 10)

year.append(i + 1)
age.append(new_age)
ninetieth_percentile.append(ninetieth_percentile_value)
seventy_fifth_percentile.append(seventy_fifth_percentile_value)
median.append(median_value)
twenty_fifth_percentile.append(twenty_fifth_percentile_value)
tenth_percentile.append(tenth_percentile_value)

return pd.DataFrame(
list(
zip(year,
age,
ninetieth_percentile,
seventy_fifth_percentile,
median,
twenty_fifth_percentile,
tenth_percentile)
),
columns=[
'year',
'age',
'90th_percentile',
'75th_percentile',
'median',
'25th_percentile',
'10th_percentile']
)

``````

The randomness we've introduced here is for every year in each of the 10,000 or more simulations a:

• 5% chance of negative returns between -20% and -8%
• 25% chance of negative returns between -7% and -1%
• 40% chance of low returns between 0% and 4%
• 25% chance of medium returns between 5% and 9%
• 5% chance of high returns between 10% and 20%

If you think these are too pessimistic or optimistic please go ahead change the values or weights 👍

The 'get_yearly_percentiles' function takes the 2D list 'results' (all of the histories for all simulations year by year), rotates it to line up year 1, year 2, year 3 and so on, and then finds the percentiles (10th, 25th, median, 75th, 90th) for each year. This effectively shows the range of results from all simulations for each year in a DataFrame:

yearage90th_percentile75th_percentilemedian25th_percentile10th_percentile
1211145011300111001099010970
2221815317804173991711016957
32325296.124570.252391923395.7523051
4243263131605306322983229279.8
52540342.138841.2537513.536407.7535624.9
.....................
4161618714.6553043.8492832442674.5403963.4
4262645462.7578133514355461004.3420718
4363673703602295535547478970437741.3
4464703538.1629788.8557324.5498292.3453481.4
4565739303.7656680.5580414.5517842470615.8

This can then be plotted using Plotly along with the final pot sizes.

## Plotting the Monte Carlo results with Plotly

I was using Spyder to carry out this analysis, and saved the plots as html files in the /output directory. You'll need to install Plotly with `python -m pip install plotly`

plots.py
``````import numpy as np
import plotly.express as px
import plotly.graph_objects as go
import plotly.io as pio

pio.renderers.default='svg'

def plot_histogram(pot_sizes: list,
upper_confidence:float,
lower_confidence: float):
"""
Plots the frequencies of the final pot sizes.
"""
fig = px.histogram(pot_sizes,
title=f"The final pot size after {len(pot_sizes)} simulations.")

line_width=3,
line_dash="dash",
line_color="green")

line_width=3,
line_dash="dash",
line_color="green")

line_width=3,
line_dash="dash",
line_color="black",
annotation_text="median",
annotation_font_size=15)

x1=upper_confidence,
line_width=0,
fillcolor="green",
opacity=0.2,
annotation_text="95% confidence interval",
annotation_font_size=15)

fig.update_layout(
xaxis_title="Amount (£)",
yaxis_title="Count",
showlegend=False,
font=dict(
family="Arial",
size=14
),
paper_bgcolor='rgba(0,0,0,0)',
plot_bgcolor='rgba(0,0,0,0)',
)

fig.write_html('outputs/mc-histogram.html', auto_open=False)

def plot_yearly_percentiles(inputs, df):
"""
Plots the year by year percentile graph.
"""
exact_np = df[df['90th_percentile'] > inputs['target_amount']].iloc
exact_sfp = df[df['75th_percentile'] > inputs['target_amount']].iloc
exact_median = df[df['median'] > inputs['target_amount']].iloc
exact_tfp = df[df['25th_percentile'] > inputs['target_amount']].iloc
exact_tp = df[df['10th_percentile'] > inputs['target_amount']].iloc

fig = go.Figure()

y=df['10th_percentile'],
line = dict(color='#FFA502'),
mode='lines',
name='10th %tile',
fill='none',
fillcolor = '#F7CA77'))

y=df['25th_percentile'],
line = dict(color='#7BE56E'),
mode='lines',
name='25th %tile',
fill='tonexty',
fillcolor = '#F7CA77'))

y=df['median'],
line=dict(color='black'),
line_width=3,
mode='lines',
name="median",
fill='tonexty',
fillcolor='#00FF66'))

y=df['75th_percentile'],
line = dict(color='#7BE56E'),
mode='lines',
name="75th %tile",
fill='tonexty',
fillcolor = '#00FF66'))

y=df['90th_percentile'],
line = dict(color='#FFA502'),
mode='lines',
name="90th %tile",
fill='tonexty',
fillcolor = '#F7CA77'))

fig.update_layout(hovermode="x")

fig.update_xaxes(tickangle=0,
dtick=1,
showticklabels=True,
gridcolor='lightgray',
type='category')

fig.update_yaxes(gridcolor='lightgray',
rangemode="tozero")

line_width=2,
line_dash='dash',
line_color='red',
annotation_text='Target amount',
annotation_font=dict(
family="Arial",
size=15,
color="red"
),
annotation_font_size=15,
annotation_position='bottom left',
fillcolor='red')

x0=int(exact_median['year'] - 1),
y0=0,
x1=int(exact_median['year'] - 1),
y1=inputs['target_amount'],
line_width=2,
line_color='gray',
line_dash='dash')

x0=int(exact_tp['year'] - 1),
y0=0,
x1=int(exact_tp['year'] - 1),
y1=inputs['target_amount'],
line_width=2,
line_color='orange',
line_dash='dash')

x0=int(exact_np['year'] - 1),
y0=0,
x1=int(exact_np['year'] - 1),
y1=inputs['target_amount'],
line_width=2,
line_color='orange',
line_dash='dash')

x0=int(exact_tfp['year'] - 1),
y0=0,
x1=int(exact_tfp['year'] - 1),
y1=inputs['target_amount'],
line_width=2,
line_color='green',
line_dash='dash')

x0=int(exact_sfp['year'] - 1),
y0=0,
x1=int(exact_sfp['year'] - 1),
y1=inputs['target_amount'],
line_width=2,
line_color='green',
line_dash='dash')

y=inputs['target_amount'] * 1.45,
text=f"<b>{int(exact_median['year'])} years</b>",
font=dict(
color="black",
size=21
),
showarrow=False,
yshift=10)

y=inputs['target_amount'] * 1.3,
text=f"<b>(Age {int(exact_median['age'])})</b>",
font=dict(
color="black",
size=21
),
showarrow=False,
yshift=10)

y=df['10th_percentile'].max() - 8000,
text="<b>10%</b>",
font=dict(
color="black",
size=12
),
showarrow=False,
yshift=10)

y=df['25th_percentile'].max() - 8000,
text="<b>25%</b>",
font=dict(
color="black",
size=12
),
showarrow=False,
yshift=10)

y=df['median'].max() - 5000,
text="<b>median</b>",
font=dict(
color="black",
size=12
),
showarrow=False,
yshift=10)

y=df['75th_percentile'].max() - 4000,
text="<b>75%</b>",
font=dict(
color="black",
size=12
),
showarrow=False,
yshift=10)

y=df['90th_percentile'].max() - 5000,
text="<b>90%</b>",
font=dict(
color="black",
size=12
),
showarrow=False,
yshift=10)

xref='paper',
xanchor='right',
y=0,
yanchor='bottom',
font=dict(
color="gray",
size=14
),
showarrow=False)

xref='paper',
yref='paper',
xanchor='left',
y=0.99,
yanchor='top',
text=f"In <b>{inputs['n_simulations']}</b> simulations " +
f"<b>{int(exact_median['age'])}</b> " +
f"is the median age ({int(exact_median['year'])} years)<br>",
font=dict(
color="black",
size=15
),
showarrow=False)

xref='paper',
yref='paper',
xanchor='left',
y=0.96,
yanchor='top',
text="<span style=\"color:orange\">10th to 90th %ile: " +
f"<b>{int(exact_np['year'])} to {int(exact_tp['year'])} " +
"years</b> to target</span>",
font=dict(
color="black",
size=15
),
showarrow=False)

xref='paper',
yref='paper',
xanchor='left',
y=0.93,
yanchor='top',
text="<span style=\"color:green\">25th to 75th %ile: " +
f"<b>{int(exact_sfp['year'])} to {int(exact_tfp['year'])} " +
"years</b> to target</span>",
font=dict(
color="black",
size=15
),
showarrow=False)

fig.update_layout(
title=f"Percentiles by year after {inputs['n_simulations']} simulations.",
xaxis_title="Age",
yaxis_title="Amount (£)",
legend_title="Legend Title",
showlegend=False,
font=dict(
family="Arial",
size=14
),
paper_bgcolor='rgba(0,0,0,0)',
plot_bgcolor='rgba(0,0,0,0)',
)

fig.write_html('outputs/mc-percentiles.html', auto_open=False)
``````

This outputs the year by year percentiles to 'outputs/mc-percentiles.html'. The good part about the Plotly HTML output is that after uploading to GitHub it can be viewed via htmlpreview.github.io

Go ahead and take a look at the Monte Carlo percentile graph.

You can also use this to embed the interactive plot in a web page using an iframe like the one below!

``````<iframe height="800" width="100%" loading="lazy" src="https://htmlpreview.github.io/?https://raw.githubusercontent.com/shedloadofcode/monte-carlo-simulation/main/outputs/mc-percentiles.html"></iframe>
``````

We can see that the median amount crosses the target at age 51 given our inputs. However, given a better or worse outcome it could cross the target amount between ages 47 and 54.

Monte Carlo simulations are a great way to deal with uncertainty when we simply don't know what the expected values (in this case investment returns) will be.

We can also take a look at the frequencies of the final pot sizes at the end age 65 in a histogram.

We can see the 95% confidence interval is between £420k - £850k with the median pot size being £581k. This demonstrates the power of compounding and starting investing from an early age.

## Comparing the results

I have used numerous scenarios as inputs to test this model against the calculator from engaging-data.com (ED) to see how the results align, which has been pretty fun. I set the average return on the ED calculator to 4% as my model is a bit more pessimistic. As mentioned earlier, you can change the probability weights for a given set of returns in the 'get_random_returns' function if you feel more optimistic.

Here are my findings in three scenarios:

Scenario 1 inputs

InputValue
Start age20
End age65
Starting pot5,000
Annual contributions6,000
Target amount300,000
Simulations10,000

Scenario 1 results View calculator results

ModelYearsAge
This model3050
ED calculator30.350

Scenario 2 inputs

InputValue
Start age30
End age65
Starting pot10,000
Annual contributions10,000
Target amount400,000
Simulations10,000

Scenario 2 results View calculator results

ModelYearsAge
This model2656
ED calculator25.255

Scenario 3 inputs

InputValue
Start age25
End age65
Starting pot20,000
Annual contributions20,000
Target amount1,000,000
Simulations10,000

Scenario 3 results View calculator results

ModelYearsAge
This model3055
ED calculator30.255

As you can see the results are very closely aligned, so I'm very pleased with how well this model is performing. Of course, as George Box said All models are wrong, but some are useful. We should not forget that models and simulations can only give us an indication of possible outcomes, we should never blindly trust them but use them as tools. I think it's also important to keep them realistic and not introduce too much bias or ego into our assumptions. It would be great to get 10% returns every year, but is that realistically going to happen?

Lowering our model's assumptions ensures we are closer to a 'worst case scenario' and any over-performance is a bonus!

## Conclusion

We've learned lots on both Monte Carlo methods and creating / embedding Plotly visualisations with Python.

Some of the techniques used in this article with Plotly can also be used for variations of fan charts typically used for forecasting and acknowledging uncertainty.

I didn't quite get around to incrementing the results by 0.1 and plotting the circles which you can achieve with Plotly shapes. Maybe this is something you can try to replicate if you want to. I actually preferred seeing the vertical lines show which age the amount goes above the target rather than the exact intersection - this also is the foundation of statistical process control charts to make variation in the results explicit.

Thanks to engaging-data.com for giving me the inspiration to try and re-create this awesome model and visualisation with Python and Plotly.

As always, if you enjoyed this article be sure to check out other articles on the site.