A Guide to Vectorized Backtesting in Python for Trading Strategies

Image generated with the assistance of AI.

Trading strategies play a crucial role in financial markets, and before deploying any strategy in a live environment, it’s essential to evaluate its performance through backtesting. Vectorized backtesting is a powerful approach that allows you to efficiently test your trading strategies using Python, taking advantage of libraries like yfinance and pandas to process data in bulk. In this article, we’ll guide you through the steps of vectorized backtesting and provide code examples for each step.

First of all, why is it important to perform backtesting in your trading strategy? Well, let’s say that is a critical step in the development and evaluation of trading strategies for several reasons:

Historical Validation: Backtesting allows you to test your trading strategy on historical price data. It provides a way to validate the strategy’s potential performance based on past market conditions. This historical validation is essential before risking real capital in the live market.
Risk Assessment: By backtesting, you can assess the risk associated with your trading strategy. It helps you understand the maximum drawdown, potential losses, and risk-adjusted returns. This information is crucial for determining the appropriate position sizing and risk management.
Strategy Optimization: Backtesting allows you to fine-tune and optimize your trading strategy. By examining historical performance, you can identify weaknesses, improve entry and exit criteria, and refine the rules to increase the strategy’s profitability.
Confidence Building: Successful backtesting can instill confidence in a trading strategy. If your strategy performs well over an extended historical period, you’re more likely to trust it in real-time trading. However, it’s important to remember that past performance does not guarantee future success.
Scenario Testing: Backtesting enables you to simulate various market conditions and scenarios. This helps you understand how your strategy would have performed during different market phases, including bull markets, bear markets, and periods of high volatility.

For this article, we will use a strategy of simple moving average crossover. The two SMAs used in a simple moving average crossover strategy are usually a short-term SMA and a long-term SMA. The short-term SMA is more responsive to recent price changes, while the long-term SMA is more stable and reflects the overall trend. The most common periods used for the SMAs are 50 and 200, which represent the average price of the last 50 and 200 days, respectively.

The simple moving average crossover strategy generates trading signals based on the relationship between the two SMAs. When the short-term SMA crosses above the long-term SMA, it is called a golden cross, and it indicates a bullish trend. When the short-term SMA crosses below the long-term SMA, it is called a death cross, and it indicates a bearish trend.

Step 1: Data Retrieval

The first step in backtesting is to gather historical price data of a stock. For this demonstration, we’ll use Microsoft stock price (Ticker: MSFT). For this purpose, we use the yfinance library to download historical data for MSFT, between January 1, 2020, and January 1, 2022. Make sure to install the required libraries:

import yfinance as yf
import pandas as pd

# Define the ticker symbol (MSFT for Microsoft)
ticker_symbol = "MSFT"

# Retrieve historical price data from Yahoo Finance
data = yf.download(ticker_symbol, start="2020-01-01", end="2022-01-01")

Step 2: Strategy Definition

Once you have your historical data, it’s time to define your trading strategy. In this example, we’ll implement a simple moving average crossover strategy:

def moving_average_crossover_strategy(data, short_window, long_window):
    signals = pd.DataFrame(index=data.index)
    signals['Short_MA'] = data['Close'].rolling(window=short_window).mean()
    signals['Long_MA'] = data['Close'].rolling(window=long_window).mean()

    # Generate buy and sell signals
    signals['Signal'] = 0
    signals['Signal'][short_window:] = np.where(signals['Short_MA'][short_window:] > signals['Long_MA'][short_window:], 1, 0)
    signals['Position'] = signals['Signal'].diff()

    return signals

The function above, defines a basic moving average crossover trading strategy. It calculates short and long-term moving averages of historical price data and generates buy and sell signals based on the relationship between these moving averages. This strategy aims to take long positions when the short-term moving average crosses above the long-term moving average and short positions when the opposite occurs.

Step 3: Backtesting

With the trading strategy defined, you can proceed to backtest it using the generated signals. Here, we calculate the returns and equity curve:

def backtest(data, signals):
    data = data.copy()
    data['Returns'] = data['Close'].pct_change() * signals['Signal'].shift(1)
    data['Equity Curve'] = (1 + data['Returns']).cumprod()
    return data

This function calculates the returns of the strategy by multiplying the percentage change in the close price of the security by the signal shifted by one period. The signal is shifted by one period to avoid look-ahead bias, which is a common pitfall in backtesting that occurs when the strategy uses information that is not available at the time of trading.

Step 4: Performance Metrics

Evaluating your trading strategy’s performance is essential. You can calculate various performance metrics such as the total return, sharpe ratio, maximum drawdown, and more. For our case, we will use the three metrics mentioned before:

def calculate_performance_metrics(data):
    total_return = data['Equity_Curve'][-1] - 1
    daily returns = data['Returns'].dropna()
    sharpe_ratio = (daily_returns.mean() / daily_returns.std()) * np.sqrt(252)
    max_drawdown = (data['Equity Curve'] / data['Equity_Curve'].cummax() - 1).min()

    return {
        'Total Return': total_return,
        'Sharpe Ratio': sharpe_ratio,
        'Max Drawdown': max_drawdown,
    }

The code above evaluates the performance of the trading strategy that has an equity curve and returns data. Why we use square root of 252 to annualize the sharpe ratio? quick answer, there are 252 trading days in a year, however, here is a great paper by Andy Lo about this topic, where this is explained better.

Step 5: Putting It All Together

Now that you’ve gone through the individual steps, you can assemble them to execute your vectorized backtest:

import yfinance as yf
import numpy as np
import pandas as pd

# Define parameters
short_window = 50
long_window = 200

# Data Retrieval using yfinance
ticker_symbol = "MSFT"
data = yf.download(ticker_symbol, start="2020-01-01", end="2022-01-01")

# Strategy Definition
signals = moving_average_crossover_strategy(data, short_window, long_window)

# Backtesting
backtested_data = backtest(data, signals)

# Performance Metrics
performance_metrics = calculate_performance_metrics(backtested_data)

print("Performance Metrics:")
for metric, value in performance_metrics.items():
    print(f"{metric}: {value:.4f}")

The result of the performance metrics are:

Performance Metrics:
Total Return: 0.5311
Sharpe Ratio: 1.3321
Max Drawdown: -0.0877

Let’s interprete these metrics results:

Total Return:

The Total Return represents the overall return on investment generated by our trading strategy over a specified period. It’s often expressed as a percentage.
In this case (Total Return: 0.5311), this means that for every dollar invested, we would have earned $0.5311. This metric helps to understand the profitability of the strategy.
A positive total return indicates that your strategy generated a profit, while a negative value suggests a loss.

Sharpe Ratio:

The Sharpe Ratio is a risk-adjusted performance measure that helps assess the return generated per unit of risk taken.
It calculates the excess return (returns above a risk-free rate) divided by the standard deviation of those returns. The standard deviation is a measure of risk or volatility.
In our case (Sharpe Ratio: 1.3321), this ratio indicates that for each unit of risk taken, we earned approximately 1.3321 units of return. A higher sharpe ratio typically indicates a more favorable risk-reward trade-off.
A sharpe ratio greater than 1 is often considered good, while a ratio above 2 is typically seen as excellent. Keep in mind that this metric is most relevant when comparing different strategies or portfolios.

Max Drawdown:

The Maximum Drawdown represents the largest peak-to-trough decline or loss in the equity curve of your trading strategy.
In our case, the drawdown is -0.0877, which means our strategy experienced a maximum loss of 8.77% at some point during the backtesting period.
A lower maximum drawdown is generally better, as it indicates that the strategy’s losses were limited and that it is more robust and less risky. Traders and investors often pay close attention to this metric when evaluating risk.

Conclusion

This case covers the basics of vectorized backtesting in Python. You can further refine your strategy, incorporate risk management rules, and explore advanced performance metrics to gain a deeper understanding of the performance of your trading strategy. Note that this is simple backtesting using a simple strategy, however, depending on your strategy, this could be complex, but it is always best to ensure better results for your trading strategy.

In Plain English

Thank you for being a part of our community! Before you go:

Be sure to clap and follow the writer! 👏
You can find even more content at PlainEnglish.io 🚀
Sign up for our free weekly newsletter. 🗞️
Follow us: Twitter(X), LinkedIn, YouTube, Discord.
Check out our other platforms: Stackademic, CoFeed, Venture.