Backtest Statistics into Code

You can access your algorithm's current Sharpe ratio, drawdown, annualized return, and alpha during a backtest through the backtest report and the API.

The backtest report displays time series for your portfolio's rolling beta and Sharpe ratio. The chart displays the peak-to-trough drawdown of your portfolio's equity throughout the backtest period. The drawdown of each day is defined as the percentage loss since the maximum equity value before the current day. The drawdowns are calculated based on daily data. The top 5 drawdown periods are marked in the chart with different colors.

In the API, the AlphaRuntimeStatistics model contains insight population run time statistics. The TotalAccumulatedEstimatedAlphaValue field gives the total accumulated estimated value of trading all insights.

Here is an example of how you can access these statistics in Python:

# Access the statistics
statistics = self.GetAlgorithmStatistics()

# Get the Sharpe ratio, drawdown, annualized return, and alpha
sharpe_ratio = statistics["SharpeRatio"]
drawdown = statistics["Drawdown"]
annual_return = statistics["CompoundingAnnualReturn"]
alpha = statistics["Alpha"]

# Print the statistics
self.Debug(f"Sharpe Ratio: {sharpe_ratio}")
self.Debug(f"Drawdown: {drawdown}")
self.Debug(f"Annual Return: {annual_return}")
self.Debug(f"Alpha: {alpha}")

Please note that this code should be placed in the OnEndOfAlgorithm method to ensure that the statistics are calculated after the algorithm has finished processing all data.

For more information, you can refer to the QuantConnect API documentation.

Please note that the statistics are calculated after the backtest has completed, so they cannot be accessed during the backtest for plotting over time. However, you can manually calculate these statistics and plot them during the backtest.

Oh, Mia, you've done it again! Thank you!

How would you suggest I calculate these statistics at runtime? Should I use indicators like this Sharpe Ratio Indicator?

Yes, you're on the right track! QuantConnect provides a built-in Sharpe Ratio indicator that you can use to calculate the Sharpe Ratio at runtime. Here's how you can use it in Python:

def Initialize(self):
    self.symbol = self.AddEquity("SPY", Resolution.Daily).Symbol
    self.sr = self.SR(self.symbol, 22, 0.03)

def OnData(self, data):
    if self.sr.IsReady:
        self.Plot("SharpeRatio", "sr", self.sr)

In this example, SR is a helper method from the QCAlgorithm class that creates a SharpeRatio object, hooks it up for automatic updates, and returns it so you can use it in your algorithm. You should call this helper method in the Initialize method.

For other statistics like drawdown, annualized return, and alpha, you might need to implement custom calculations. For example, you can calculate drawdown by keeping track of the highest portfolio value and comparing it with the current portfolio value. Annualized return can be calculated by taking the total return over the backtest period and raising it to the power of (1 / number of years), then subtracting 1. Alpha can be more complex to calculate, as it typically involves comparing the performance of your strategy to a benchmark.

Please note that these are simplified explanations and the actual calculations can be more complex, especially when taking into account factors like risk-free rate and trading costs. You can refer to the QuantConnect documentation for more details on how these statistics are calculated.

Thank you! Is there any way I can access a breakdown of stocks traded throughout the backtest? I can imagine this would be quite easy to do programmatically (with some sort of frequency map), but is there an in-built function for it?

There isn't a built-in function to get a breakdown of stocks traded throughout the backtest. However, you can easily track this information programmatically by creating a dictionary to store the symbol and its corresponding trade count. Here's an example of how you can do this in Python:

class MyAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.symbols = {}

    def OnData(self, data):
        # Trading logic here
        # ...

        # After placing a trade, update the symbols dictionary
        if self.Portfolio.Invested:
            for holding in self.Portfolio.Values:
                symbol = holding.Symbol
                if symbol not in self.symbols:
                    self.symbols[symbol] = 0
                self.symbols[symbol] += 1

    def OnEndOfAlgorithm(self):
        # At the end of the algorithm, print the symbols and their trade counts
        self.Debug(str(self.symbols))

In this example, self.symbols is a dictionary where the keys are the symbols and the values are the trade counts. After each trade, the algorithm updates the dictionary. At the end of the algorithm, it prints the dictionary to the console.

Please note that this is a simplified example and you might need to adjust it based on your specific trading logic. For example, if you're using limit orders, you might want to increment the count only when the order is filled, which you can check in the OnOrderEvent method.

Sorry for the trouble! I am having a little issue accessing my algorithm's statistics! In the OnEndOfAlgorithm function, I have placed your code. However, it is throwing the error:

'TomsFactorAlgorithm' object has no attribute 'GetAlgorithmStatistics'
  at OnEndOfAlgorithm
    statistics = self.GetAlgorithmStatistics()

where TomsFactorAlgorithm inherits from QCAlgorithm.

What could be the issue?

I apologize for the confusion. The GetAlgorithmStatistics method is not available in the algorithm context during a backtest or live trading. It's a method available in the API to fetch the statistics after a backtest has completed.

If you want to log the statistics at the end of the algorithm, you can use the OnEndOfAlgorithm method to log the trades. Here's an example from the QuantConnect forum:

def OnEndOfAlgorithm(self):
    for trade in self.TradeBuilder.ClosedTrades:
        self.Log(self.trade_to_string(trade))

def trade_to_string(self, trade):
    return 'Symbol: {0} EntryTime: {1} EntryPrice {2} Direction: {3} Quantity: {4} ExitTime: {5} ExitPrice: {6} ProfitLoss: {7} TotalFees: {8} MAE: {9} MFE: {10} EndTradeDrawdown: {11}'.format(
        trade.Symbol,
        trade.EntryTime,
        trade.EntryPrice,
        trade.Direction,
        trade.Quantity,
        trade.ExitTime,
        trade.ExitPrice,
        trade.ProfitLoss,
        trade.TotalFees,
        trade.MAE,
        trade.MFE,
        trade.EndTradeDrawdown)

This will log the details of each closed trade, including the symbol, entry time, entry price, direction, quantity, exit time, exit price, profit/loss, total fees, MAE, MFE, and end trade drawdown.

For more complex statistics like Sharpe ratio, drawdown, annualized return, and alpha, you might need to implement custom calculations as I mentioned in the previous message.

How about this property of the algorithm? Could I use this to track SR, DD and more?

Yes, you can use the Statistics property of the algorithm class to track various statistics of your algorithm. The StatisticsResults object tracks all the statistics of your algorithm. You can access the statistics anywhere in your algorithm where you have a reference to the algorithm class.

Here's how you can access the Sharpe Ratio in Python:

sharpe = self.Statistics.TotalPerformance.PortfolioStatistics.SharpeRatio

The StatisticsResults object has the following properties:

• TotalPerformance: The performance of the algorithm over the whole period
• RollingPerformances: The rolling performance of the algorithm over 1, 3, 6, 12 month periods
• Summary: Returns a summary of the algorithm performance as a dictionary

To add custom statistics to the StatisticsResults object, call the SetSummaryStatistic method with the statistic name and value.

self.SetSummaryStatistic("name", value)

To get the value of a custom statistic, index the Summary member with the statistic name. The values in the Summary dictionary are strings, so you may need to cast the value that returns to a different data type.

value = self.Statistics.Summary["name"]

Please note that these statistics are calculated after the backtest has completed, so they cannot be accessed during the backtest for plotting over time. However, you can manually calculate these statistics and plot them during the backtest.

For more information, you can refer to the QuantConnect documentation.

Thanks, Mia! How do you respond to my questions so fast? You are a fantastic moderator. :)