Building a Mean Reversion

Trading System with Python.

The Mean Reversion System is a popular trading strategy

that relies on the statistical concept of mean reversion.
This principle suggests that prices and returns eventually
return to their historical average or mean.
Traders employing this strategy look for opportunities to
profit from price deviations from the mean, expecting the
price to revert to its average over time. To summarize:
Mean reversion is a financial theory that assumes
asset prices fluctuate around a stable long-term
average.
This type of trading system is generally well-suited for
sideways markets, where prices do not follow a specific
direction but instead fluctuate above and below the
average over a certain period.
Therefore, I will design and develop a mean reversion
system to maximize profits in sideways markets while
minimizing the drawdown during bearish markets. The
indicators best suited for this purpose are Bollinger
Bands and RSI.

From the candlestick chart, we will use observation to

define the entry and exit conditions as follows:
Entry Conditions:

 The closing price is below the lower Bollinger Band

 The RSI is below 30 (indicating oversold conditions)

Exit Conditions:

 The closing price rises above the Bollinger Band’s

mean
From now on, it will be a step-by-step to building a trading
system and performing optimization with Python.

1. Imports

import numpy as np
import pandas as pd
import yfinance as yf
import vectorbt as vbt
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

 numpy and pandas: For numerical and data

manipulation tasks.

 yfinance: To download historical stock data.

 vectorbt: To perform backtesting and analyze

portfolios.

 matplotlib.pyplot and mpl_toolkits.mplot3d: For

plotting 3D graphs.
2. Functions for Technical Indicators

# Function to calculate Bollinger Bands

def calculate_bollinger_bands(df, window=20, std_dev=2):
"""Calculate Bollinger Bands."""
df['Mean'] = df['Close'].rolling(window=window).mean()
df['Std'] = df['Close'].rolling(window=window).std()
df['Upper_Band'] = df['Mean'] + (std_dev * df['Std'])
df['Lower_Band'] = df['Mean'] - (std_dev * df['Std'])
return df

 calculate_bollinger_bands: This function calculates the

Bollinger Bands, which consist of 3 components:

 Mean (the moving average of the closing prices),

 Upper Band (Mean + standard deviation * a

multiplier),

 Lower Band (Mean — standard deviation * a

multiplier).

 It uses a rolling window (default of 20 days) and a

standard deviation multiplier (default of 2) to
calculate these bands.

# Function to calculate RSI

def calculate_rsi(df, period=14):
"""Calculate Relative Strength Index (RSI)."""
delta = df['Close'].diff()
gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
rs = gain / loss
df['RSI'] = 100 - (100 / (1 + rs))
return df
  calculate_rsi: This function calculates the Relative
Strength Index (RSI), which is a momentum
oscillator that measures the speed and change of
price movements. It is computed using the average
gains and losses over a specified period (default of 14
days).

3. Data Download

# Define the stock symbol and time period

symbol = 'INTC'
start_date = '2014-01-01'
end_date = '2024-12-27'

# Download the data

df = yf.download(symbol, start=start_date, end=end_date)
df.columns = ['Adj Close', 'Close', 'High', 'Low', 'Open', 'Volume']
df.ffill(inplace=True)

 symbol = 'SI=F': Specifies the stock symbol for Silver

Futures (SI=F).

 start_date = '2014-01-01' and end_date = '2024-12-27':

Defines the time range for the stock data.

 df = yf.download(symbol, start=start_date, end=end_date):

Downloads the historical data for Silver Futures from

Yahoo Finance.

 df.columns = ['Adj Close', 'Close', 'High', 'Low', 'Open',

'Volume']: Renames the columns of the downloaded

DataFrame to standard names.
  df.ffill(inplace=True): Forward-fills any missing data (in
case there are gaps in the data).

4. Parameter Combinations for Optimization

# Initialize arrays to store results

results = []
window_range = range(1, 50) # Example range for window
std_dev_range = np.arange(1, 4, 0.5) # Example range for std_dev
period_range = range(1, 30) # Example range for period

 The script then sets up parameter ranges for the

Bollinger Bands and RSI:

 window_range = range(1, 50): Range of window sizes for

the moving average.

 std_dev_range = np.arange(1, 4, 0.5): Range of standard

deviation multipliers.

 period_range = range(1, 30): Range of periods for

calculating the RSI.

5. Loop for Backtesting and Optimization

# Loop through all combinations of window, std_dev, and period

for window in window_range:
for std_dev in std_dev_range:
for period in period_range:
# Calculate Bollinger Bands and RSI for current parameter set
temp_df = df.copy()
temp_df = calculate_bollinger_bands(temp_df, window=window,
std_dev=std_dev)
 temp_df = calculate_rsi(temp_df, period=period)

# Define entry and exit signals

temp_df['Buy_Signal'] = (temp_df['Close'] <
temp_df['Lower_Band']) & (temp_df['RSI'] < 30)
temp_df['Sell_Signal'] = (temp_df['Close'] >
temp_df['Upper_Band']) & (temp_df['RSI'] > 70)
temp_df['Exit_Buy'] = (temp_df['Close'] > temp_df['Mean'])
temp_df['Exit_Sell'] = (temp_df['Close'] < temp_df['Mean'])

# Convert signals to boolean arrays

entries = temp_df['Buy_Signal'].to_numpy()
exits = temp_df['Exit_Buy'].to_numpy()

# Backtest using vectorbt

portfolio = vbt.Portfolio.from_signals(
close=temp_df['Close'],
entries=entries,
exits=exits,
init_cash=100_000,
fees=0.001
)

# Store results (final portfolio value, can also include

Sharpe ratio or other metrics)
results.append((window, std_dev, period,
portfolio.stats().loc['Total Return [%]']))

# Convert results to DataFrame for easy plotting

results_df = pd.DataFrame(results, columns=['Window', 'Std_Dev', 'Period',
'Total Return [%]'])

 For each combination of parameters (window, std_dev,

and period), the following steps are performed:

1. Bollinger Bands and RSI Calculation: For each
combination, the Bollinger Bands and RSI are calculated
using the respective functions.
2. Define Entry and Exit Signals:

 Buy Signal: The code generates a signal to buy when

the closing price is below the lower Bollinger
 Band and the RSI is below 30 (indicating that the
asset is oversold).

 Exit Buy: A sell signal is triggered when the closing

price crosses above the moving average (the
“Mean”).
3. Backtesting with vectorbt:

 A portfolio is created using the from_signals method

from vectorbt, which simulates the strategy based on
the entry and exit signals, an initial cash amount of
100,000, and a fee of 0.1%.
4. Store Results: The results (final total return) are
stored in an array results for later analysis.

6. Data Preparation for 3D Plotting

# Extract data for 3D plotting

x = results_df['Window']
y = results_df['Std_Dev']
z = results_df['Period']
value = results_df['Total Return [%]']

# Create a 3D plot of the optimization results

fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x, y, z, c=value, cmap='viridis', marker='o')
ax.set_xlabel('Window')
ax.set_ylabel('Std Dev')
ax.set_zlabel('Period')
ax.set_title('Optimization of Bollinger Bands and RSI Parameters')
plt.show()
  Results DataFrame: After the loop, the results are
stored in a DataFrame (results_df) that includes
the window, std_dev, period, and the Total Return [%] for
each combination.

 3D Plot: The code is then used matplotlib to create a

3D scatter plot of the results:

 x-axis: Window size for the Bollinger Bands.

 y-axis: Standard deviation multiplier for the Bollinger

Bands.

 z-axis: Period for the RSI.

 Color: The color of the points represents the total

return percentage.

7. Identify the Best Parameters

# Find the best parameter combination (highest final portfolio value)

best_params = results_df.loc[results_df['Total Return [%]'].idxmax()]

# Print the best parameters and corresponding final portfolio value

print(f"Best Parameters:")
print(f"Window: {best_params['Window']}")
print(f"Std Dev: {best_params['Std_Dev']}")
print(f"Period: {best_params['Period']}")
print(f"Final Portfolio Value: {best_params['Total Return [%]']}")

 Best Parameter Combination: The code identifies

the combination of window, std_dev, and period that
results in the highest total return by finding the row
 with the maximum value in the Total Return

[%] column.

 Print the Best Parameters: The best parameters

and the corresponding final portfolio value are
printed to the console.
Full Code Here:

import numpy as np
import pandas as pd
import yfinance as yf
import vectorbt as vbt
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Function to calculate Bollinger Bands

def calculate_bollinger_bands(df, window=20, std_dev=2):
"""Calculate Bollinger Bands."""
df['Mean'] = df['Close'].rolling(window=window).mean()
df['Std'] = df['Close'].rolling(window=window).std()
df['Upper_Band'] = df['Mean'] + (std_dev * df['Std'])
df['Lower_Band'] = df['Mean'] - (std_dev * df['Std'])
return df

# Function to calculate RSI

def calculate_rsi(df, period=14):
"""Calculate Relative Strength Index (RSI)."""
delta = df['Close'].diff()
gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
rs = gain / loss
df['RSI'] = 100 - (100 / (1 + rs))
return df

# Define the symbol and time period

symbol = 'SI=F'
start_date = '2014-01-01'
end_date = '2024-12-27'

# Download the data

df = yf.download(symbol, start=start_date, end=end_date)
df.columns = ['Adj Close', 'Close', 'High', 'Low', 'Open', 'Volume']
df.ffill(inplace=True)

# Initialize arrays to store results

results = []
window_range = range(1, 50) # Example range for window
std_dev_range = np.arange(1, 4, 0.5) # Example range for std_dev
period_range = range(1, 30) # Example range for period

# Loop through all combinations of window, std_dev, and period

for window in window_range:
for std_dev in std_dev_range:
for period in period_range:
# Calculate Bollinger Bands and RSI for current parameter set
temp_df = df.copy()
temp_df = calculate_bollinger_bands(temp_df, window=window,
std_dev=std_dev)
temp_df = calculate_rsi(temp_df, period=period)

# Define entry and exit signals

temp_df['Buy_Signal'] = (temp_df['Close'] <
temp_df['Lower_Band']) & (temp_df['RSI'] < 30)
temp_df['Exit_Buy'] = (temp_df['Close'] > temp_df['Mean'])

# Convert signals to boolean arrays

entries = temp_df['Buy_Signal'].to_numpy()
exits = temp_df['Exit_Buy'].to_numpy()

# Backtest using vectorbt

portfolio = vbt.Portfolio.from_signals(
close=temp_df['Close'],
entries=entries,
exits=exits,
init_cash=100_000,
fees=0.001
)

# Store results (final portfolio value, can also include

Sharpe ratio or other metrics)
results.append((window, std_dev, period,
portfolio.stats().loc['Total Return [%]']))

# Convert results to DataFrame for easy plotting

results_df = pd.DataFrame(results, columns=['Window', 'Std_Dev', 'Period',
'Total Return [%]'])

# Extract data for 3D plotting

x = results_df['Window']
y = results_df['Std_Dev']
z = results_df['Period']
value = results_df['Total Return [%]']

# Create a 3D plot of the optimization results

fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x, y, z, c=value, cmap='viridis', marker='o')
ax.set_xlabel('Window')
ax.set_ylabel('Std Dev')
ax.set_zlabel('Period')
ax.set_title('Optimization of Bollinger Bands and RSI Parameters')
plt.show()
# Find the best parameter combination (highest final portfolio value)
best_params = results_df.loc[results_df['Total Return [%]'].idxmax()]

# Print the best parameters and corresponding final portfolio value

print(f"Best Parameters:")
print(f"Window: {best_params['Window']}")
print(f"Std Dev: {best_params['Std_Dev']}")
print(f"Period: {best_params['Period']}")
print(f"Final Portfolio Value: {best_params['Total Return [%]']}")

After running the Python code, the result will be as

follows:

Best Parameters:

 Window: 41.0

 Std Dev: 1.0

 Period: 21.0

 Final Portfolio Value: 154.8820997183831

Now, we will take this best parameter and backtest it
again to see the various statistics.

import numpy as np
import pandas as pd
import yfinance as yf
import vectorbt as vbt
import matplotlib.pyplot as plt

# Function to calculate Bollinger Bands

def calculate_bollinger_bands(df, window=20, std_dev=2):
"""Calculate Bollinger Bands."""
df['Mean'] = df['Close'].rolling(window=window).mean()
df['Std'] = df['Close'].rolling(window=window).std()
df['Upper_Band'] = df['Mean'] + (std_dev * df['Std'])
df['Lower_Band'] = df['Mean'] - (std_dev * df['Std'])
 return df

# Function to calculate RSI

def calculate_rsi(df, period=14):
"""Calculate Relative Strength Index (RSI)."""
delta = df['Close'].diff()
gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
rs = gain / loss
df['RSI'] = 100 - (100 / (1 + rs))
return df

# Define the symbol and time period

symbol = 'SI=F'
start_date = '2014-01-01'
end_date = '2024-12-27'

# Download the data

df = yf.download(symbol, start=start_date, end=end_date)
df.columns = ['Adj Close', 'Close', 'High', 'Low', 'Open', 'Volume']
df.ffill(inplace=True)

# Calculate Bollinger Bands and RSI

df = calculate_bollinger_bands(df, window=41, std_dev=1)
df = calculate_rsi(df, period=21)

# Define entry and exit signals

df['Buy_Signal'] = (df['Close'] < df['Lower_Band']) & (df['RSI'] < 30)
df['Exit_Buy'] = (df['Close'] > df['Mean'])

# Convert signals to boolean arrays

entries = df['Buy_Signal'].to_numpy()
exits = df['Exit_Buy'].to_numpy()

# Backtest using vectorbt

portfolio = vbt.Portfolio.from_signals(
close=df['Close'],
entries=entries,
exits=exits,
init_cash=100_000,
fees=0.001
)

# Display performance metrics

print(portfolio.stats())

# Plot equity curve

portfolio.plot().show()

This Python code has the same indicator functions, data

download, and trading conditions as before. The only
addition is the backtest using the best parameters. The
results are as follows:

Performance Metrics

Performance Visualization

From testing the trading system with silver for almost 11

years, it was observed that although the system had
periods of negative returns, these were due to the drop in
silver prices.
Even though the prices fell, the trading system was still
able to perform better than buy and hold from that point
onward. After 2016, the system started making profits and
has continued to do so up to the present, clearly
outperforming the market (the green line beats the gray
line).
After this, I will test the same trading conditions with other
assets to identify the strengths and weaknesses of this
system to understand it as much as possible.

Backtest and Optimize with Intel Stock (INTC)

# Define the stock symbol and time period

symbol = 'INTC'
start_date = '2014-01-01'
end_date = '2024-12-27'
Best Parameters:

 Window: 48.0

 Std Dev: 1.0

 Period: 29.0

 Final Portfolio Value: 140.6236377023705

Performance Metrics

Performance Visualization

From the backtest with Intel stock, we can see the

weaknesses of the system. In the early stages, when the
stock was in an uptrend, the system hardly generated any
entry conditions because it didn’t meet the criteria.
However, once the system started going sideways in 2020
and eventually turned bearish, it was able to generate
profits and outperform the market over nearly 11 years.

Backtest and Optimize with Gold (GC=F)

# Define the Gold symbol and time period

symbol = 'GC=F'
start_date = '2014-01-01'
end_date = '2024-12-27'
Best Parameters:

 Window: 37.0

 Std Dev: 1.5

 Period: 15.0

 Final Portfolio Value: 96.16868596766638

Performance Metrics

Performance Visualization

From the backtest with gold, it can be seen that the system
generates more consistent profits compared to buy and
hold but buy and hold yields a higher profit over the 11
years.
The trading system and buy-and-hold alternate in
profitability, with the system performing better during
periods when gold enters consolidation or retracement
phases, as observed from 2014 to 2019.
However, when gold entered a bullish phase from 2020 to
2021, the system could not generate profits comparable to
the market’s uptrend. But once it entered a consolidation
phase again, the system outperformed buy and hold.
From the experiment with the mean reversion system
across all 3 markets, the conclusion is that this
system performs well in sideways and bearish
markets, as it can filter out losses.
Therefore, if we want to apply this system, it is essential to
understand the overall market fundamentals and predict
when the market is in an uptrend to switch to a buy-and-
hold strategy.
Conversely, when the market enters a consolidation phase,
we should switch back to using this trading system. This
approach will make trading more effective. Understanding
the overall market fundamentals is not an impossible task,
and you can further study it through the article below:
M2 as a Predictor for Market Trends
Building an Investment Strategy Around Money Supply (M2)
wire.insiderfinance.io

If you read this article to the end, you will notice that
almost every image I included has a watermark with
my own logo. I want to explain that this is necessary
because someone copied my article and posted it on
their own website under their name, without giving
credit. To prevent anyone from copying my work, I
had to add these watermarks. I truly apologize for
this, as I originally wrote the entire article as a
personal study record. However, I felt the need to
add these watermarks in order to maintain my
dignity. I apologize again and thank you for your
understanding.
The purpose of this article is solely educational. It is not
intended as investment advice or recommendations.
Readers are encouraged to use their own judgment and
test the system independently before making any
decisions.