Algo Trading Strategy: Mean Reversion Strategy (Bollinger Bands)

Mean reversion strategies are among the most popular approaches in algorithmic trading, capitalising on the tendency of asset prices to return to their average value after deviating significantly. This automated trading strategy uses Bollinger Bands, which are particularly effective for identifying overbought and oversold conditions in algo trading systems.

How It Works

• Buy Signal: When price touches or crosses below the lower Bollinger Band
• Sell Signal: When price touches or crosses above the upper Bollinger Band

Implementing Mean Reversion with Python for Algo Trading  

Python has become the popular language for algorithmic trading using Python due to its powerful libraries and easy implementation. This trading strategy in Python uses important libraries, such as pandas for data manipulation and analysis, numpy for numerical calculations, yfinance for stocks data fetching, and matplotlib for visualisation. Our automated trading implementation demonstrates how to calculate Bollinger Bands using a 20-period moving average and standard deviation, generate buy/sell signals when prices touch the bands, and manage positions programmatically. The beauty of Python for algo trading is in its ability to manage and backtest strategies efficiently, calculate performance metrics like Sharpe ratio and maximum drawdown, and visualise results through comprehensive charts. Abapting algorithmic trading approach eliminates emotional decision-making with providing quantitative insights into strategy performance.

Python Implementation

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

# Download historical data
ticker = "INFY.NS"
data = yf.download(ticker, start="2020-01-01", end="2023-01-01", auto_adjust=False)

# If the DataFrame has a multi-level column index, flatten it
if isinstance(data.columns, pd.MultiIndex):
    data.columns = ['_'.join(col).strip() for col in data.columns.values]

# Print to verify column names 
print("Columns:", data.columns)

# Ensure 'Close' column exists and is 1-D 
close_col = [col for col in data.columns if 'Close' in col][0]
data['Close'] = pd.to_numeric(data[close_col], errors='coerce')

# Calculate Bollinger Bands
data['MA20'] = data['Close'].rolling(window=20).mean()
data['STD20'] = data['Close'].rolling(window=20).std()
data['Upper_Band'] = data['MA20'] + (data['STD20'] * 2)
data['Lower_Band'] = data['MA20'] - (data['STD20'] * 2)

# Drop NaNs from rolling calculations
data = data.dropna()

# Generate trading signals
data['Signal'] = 0
data.loc[data['Close'] < data['Lower_Band'], 'Signal'] = 1 # Buy
data.loc[data['Close'] > data['Upper_Band'], 'Signal'] = -1 # Sell

data['Position'] = data['Signal'].replace(0, np.nan).ffill().fillna(0)

# Strategy returns
data['Return'] = data['Close'].pct_change()
data['Strategy'] = data['Position'].shift(1) * data['Return']

# Cumulative returns
data['Cumulative_Market_Return'] = (1 + data['Return']).cumprod()
data['Cumulative_Strategy_Return'] = (1 + data['Strategy']).cumprod()

# Plot Bollinger Bands
plt.figure(figsize=(12, 8))
plt.plot(data.index, data['Close'], label='Close Price')
plt.plot(data.index, data['Upper_Band'], label='Upper Band', linestyle='--')
plt.plot(data.index, data['Lower_Band'], label='Lower Band', linestyle='--')
plt.plot(data.index, data['MA20'], label='20-Day MA')
plt.fill_between(data.index, data['Upper_Band'], data['Lower_Band'], alpha=0.1)
plt.title('Bollinger Bands Mean Reversion Strategy') 
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.grid(True)
plt.show()

# Plot performance
plt.figure(figsize=(12, 8))
plt.plot(data.index, data['Cumulative_Market_Return'], label=f'{ticker} Buy and Hold')
plt.plot(data.index, data['Cumulative_Strategy_Return'], label='Mean Reversion Strategy')
plt.title('Mean Reversion Strategy Performance')
plt.xlabel('Date')
plt.ylabel('Cumulative Return')
plt.legend()
plt.grid(True)
plt.show()

# Plotting commands (not shown in browser)
if data['Strategy'].std() != 0:
    sharpe_ratio = np.sqrt(252) * (data['Strategy'].mean() / data['Strategy'].std())
else:
    sharpe_ratio = 0
max_drawdown = (data['Cumulative_Strategy_Return'] / data['Cumulative_Strategy_Return'].cummax() - 1).min()
print(f"Sharpe Ratio: {sharpe_ratio:.2f}")
print(f"Maximum Drawdown: {max_drawdown * 100:.2f}%")

Pros and Cons

Advantages:

• Works well in range-bound markets
• Provides clear entry and exit points for automated trading systems
• Adapts to changing market volatility
• Perfect for algo implementation and backtesting

Disadvantages:

• Underperforms in strongly trending markets
• Risk of significant losses during market breakouts
• Requires careful stop-loss implementation in trading algorithms
• Needs continuous monitoring despite being an automated trading strategy

Mean reversion strategies shine in volatile but range-bound markets. Consider combining this algorithmic trading approach with trend identification tools to avoid fighting against strong market trends. The key to successful algo trading is understanding when to deploy specific strategies based on market conditions.

Disclaimer

The strategies and code examples presented are for educational purposes only and do not constitute financial advice. Always conduct thorough research and consider consulting with a financial professional before implementing any trading strategies with real capital and risk management principles, and ensure compliance with SEBI guidelines before live trading. Trading involves risk—always test strategies before investing real money.