difference between backtesting time for vectorbt and backtrader

[Mayuresh28-Mayuresh]

import pandas as pd
import numpy as np
import yfinance as yf
import time
import backtrader as bt
import vectorbt as vbt

def calculate_bollinger_bands(df, window, num_std):
    rolling_mean = df['Close'].rolling(window=window).mean()
    rolling_std = df['Close'].rolling(window=window).std()
    upper_band = rolling_mean + num_std * rolling_std
    lower_band = rolling_mean - num_std * rolling_std
    return upper_band, lower_band

def implement_bollinger_band_strategy_pandas(df, window, num_std, stop_loss):
    df['UpperBand'], df['LowerBand'] = calculate_bollinger_bands(df, window, num_std)
    df['Position'] = None
    df['BuySignal'] = (df['Close'] < df['LowerBand']).astype(int)
    df['SellSignal'] = (df['Close'] > df['UpperBand']).astype(int)

    position = 0

    for i in range(len(df)):
        if df['SellSignal'][i] == 1:
            if position == 1:
                df.at[df.index[i], 'Position'] = -1
                position = 0
        elif df['BuySignal'][i] == 1:
            if position == 0:
                df.at[df.index[i], 'Position'] = 1
                position = 1

        if position == 1 and i > 0 and df['Close'][i] - df['Close'][i-1] < -stop_loss:
            df.at[df.index[i], 'Position'] = -1
            position = 0

    if position == 1:
        df.at[df.index[-1], 'Position'] = -1

def implement_bollinger_band_strategy_backtrader(data, window, num_std, stop_loss):
    class BollingerBandsStrategy(bt.Strategy):
        params = (('period', window), ('devfactor', num_std))

        def __init__(self):
            self.bollinger = bt.indicators.BollingerBands(self.data, period=self.params.period, devfactor=self.params.devfactor)

        def next(self):
            if self.data.close > self.bollinger.lines.bot:
                self.buy()
            elif self.data.close < self.bollinger.lines.top:
                self.sell()

    cerebro = bt.Cerebro()
    cerebro.addstrategy(BollingerBandsStrategy)
    cerebro.adddata(bt.feeds.PandasData(dataname=data))
    cerebro.broker.setcash(10000.0)

    try:
        start_time_backtrader = time.time()
        cerebro.run()
        end_time_backtrader = time.time()
        return end_time_backtrader - start_time_backtrader
    except Exception as e:
        print("Backtrader Error:", e)
        return None

def implement_bollinger_band_strategy_vectorbt(data, window, num_std, stop_loss):
    upper_band, lower_band = calculate_bollinger_bands(data, window, num_std)
    data['BuySignal'] = data['Close'] < lower_band
    data['SellSignal'] = data['Close'] > upper_band

    data['Position'] = 0
    data.loc[data['BuySignal'], 'Position'] = 1
    data.loc[data['SellSignal'], 'Position'] = -1

    long_mask = data['Position'] == 1
    for i in range(1, len(data)):
        if long_mask[i - 1] and data['Close'][i] - data['Close'][i - 1] < -stop_loss:
            data.at[data.index[i], 'Position'] = -1

    data.drop(columns=['BuySignal', 'SellSignal'], inplace=True)

    signals_df = data[['Close', 'Position']]

    try:
        start_time_vectorbt = time.time()
        portfolio = vbt.Portfolio.from_signals(signals_df['Close'], signals_df['Position'])
        returns = portfolio.total_return()
        end_time_vectorbt = time.time()
        return end_time_vectorbt - start_time_vectorbt
    except Exception as e:
        print("Vectorbt Error:", e)
        return None

def main():
    # Define the stock symbol and date range for historical data
    stock_symbol = 'AAPL'
    start_date = '2015-01-01'
    end_date = '2023-07-22'

    # Fetch historical data from Yahoo Finance
    df = yf.download(stock_symbol, start=start_date, end=end_date)

    # Check if the DataFrame is empty or missing data
    if df.empty or df['Close'].isnull().values.any():
        print("Error: Empty DataFrame or missing data.")
        return

    # Check if the DataFrame contains enough data points for the Bollinger Bands
    window = 20
    if len(df) < window:
        print("Error: Insufficient data points for the specified window size.")
        return

    # Define strategy parameters
    num_std = 2
    stop_loss = 0.03  # 3% stop loss

    backtesting_time_pandas = implement_bollinger_band_strategy_pandas(df.copy(), window, num_std, stop_loss)
    backtesting_time_backtrader = implement_bollinger_band_strategy_backtrader(df.copy(), window, num_std, stop_loss)
    backtesting_time_vectorbt = implement_bollinger_band_strategy_vectorbt(df.copy(), window, num_std, stop_loss)

    if backtesting_time_pandas is not None:
        print("Backtesting Time (Pandas): {:.2f} seconds".format(backtesting_time_pandas))
    if backtesting_time_backtrader is not None:
        print("Backtesting Time (Backtrader): {:.2f} seconds".format(backtesting_time_backtrader))
    if backtesting_time_vectorbt is not None:
        print("Backtesting Time (Vectorbt): {:.2f} seconds".format(backtesting_time_vectorbt))

if __name__ == "__main__":
    main()

I wrote the above code to test the backtesting time for the libraries backtrader and vectorbt. But the difference between them is significantly high . For backtrader it is : 0.98 secconds and for vectorbt it is 20.65 seconds. Is the test correct ? Is vectorbt slow ??

[polakowo]

You probably included the compilation time of numba as well (which may take up to a minute). If you run the vbt code twice it should go much faster the second time. If you're interested in benchmarking, it's recommended to use the timeit package, which runs the same code over and over again and displays the mean execution time.