Simple example of looping through backtests

Here is a code template for what 'Dat' requested:

from AlgorithmImports import *
import math
import statistics

class MultipleTickersSharpe(QCAlgorithm):
    """
    This algorithm:
    1) Reads tickers from a file named 'tickers.csv' located in the project directory.
    2) Adds each ticker as an Equity symbol (daily resolution).
    3) Collects daily returns for each symbol (computation of daily returns only, no trades).
    4) On algorithm end, computes the Sharpe Ratio for each symbol and writes the results to 'sharpe_results.csv'.
    """
    def initialize(self) -> None:
        # 1) Configure the algorithm's start and end dates
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100000)

        # 2) Attempt to read tickers from "tickers.csv" in the project directory
        self._tickers = []
        try:
            # Make sure "tickers.csv" has one ticker per line, e.g.:
            #   AAPL
            #   IBM
            #   SPY
            with open("tickers.csv", "r") as file:
                lines = file.read().strip().split("\n")
                # If the file has a header, remove it by uncommenting the next line:
                # lines = lines[1:]  # e.g. if the first line says "ticker"
                for line in lines:
                    line = line.strip()
                    if line:
                        self._tickers.append(line)
        except Exception as e:
            self.debug(f"Error reading tickers.csv: {e}")
            # If we cannot read the file, no tickers will be added. Return early.
            return

        # 3) Set up data structures for storing daily returns and previous close prices
        self._daily_returns = {}
        self._previous_closes = {}

        # 4) Add each ticker as an Equity (daily resolution)
        #    We only track daily returns, without making trades.
        for ticker in self._tickers:
            symbol = self.add_equity(ticker, Resolution.DAILY).symbol
            self._daily_returns[symbol] = []
            self._previous_closes[symbol] = 0.0

    def on_data(self, data: Slice) -> None:
        """
        Collect daily returns for each symbol by comparing the current bar close to the previous day's close.
        """
        for symbol in self._daily_returns:
            if symbol in data.bars:
                bar = data.bars[symbol]
                close_price = bar.close
                previous_close = self._previous_closes[symbol]

                # Only compute the daily return if we have a previous close
                if previous_close > 0:
                    daily_return = (close_price - previous_close) / previous_close
                    self._daily_returns[symbol].append(daily_return)

                # Update our previous-close tracking
                self._previous_closes[symbol] = close_price

    def on_end_of_algorithm(self) -> None:
        """
        At the end of the algorithm:
        1) Compute Sharpe Ratio for each symbol using daily returns.
        2) Write them out to a CSV file named 'sharpe_results.csv'.
        """
        sharpe_ratios = {}

        # Compute Sharpe Ratio for each symbol
        for symbol, returns in self._daily_returns.items():
            if len(returns) < 2:
                sharpe_ratios[symbol] = 0.0
                continue

            avg_daily_return = statistics.mean(returns)
            std_daily_return = statistics.pstdev(returns)

            # Avoid division by zero
            if std_daily_return == 0:
                sharpe = 0.0
            else:
                # Annualize using sqrt(252) for daily returns
                sharpe = (avg_daily_return / std_daily_return) * math.sqrt(252)

            sharpe_ratios[symbol] = sharpe

        # Write out the results to a CSV file
        try:
            with open("sharpe_results.csv", "w") as file:
                # Write the header
                file.write("ticker,sharpe_ratio\n")
                # Write each line: ticker, ratio
                for symbol, ratio in sharpe_ratios.items():
                    file.write(f"{symbol.value},{ratio}\n")
        except Exception as e:
            self.debug(f"Error writing sharpe_results.csv: {e}")

Instructions:

• Place a tickers.csv file with one ticker per line in your project directory.
• After running this algorithm, you will find a sharpe_results.csv file with the Sharpe Ratios for each ticker.
• The code can easily be extended to support more tickers by just expanding the CSV file.
• Each ticker is processed independently for returns, emulating separate backtests for indexing purposes. If you want truly independent backtests per ticker, you'll need to run/clone the algorithm for each ticker separately, as QuantConnect backtests are typically per-algorithm run.

Let me know if you'd like true per-backtest isolation scripting as well!

Sources: docs writing algorithms statistics algorithm statistics, Requesting Data - QuantConnect.com, Pairs Trading With Country ETFs, Multiple Symbol Consolidation Algorithm, Probabilistic Sharpe Ratio

Thanks Mia Alissi . However the example would run a single backtest for all symbols. Can the code be updated to run one backtest for each symbol consecutively?

Here is an updated approach that will run one backtest per symbol consecutively, writing the Sharpe Ratios to a CSV. This script is suitable for a QuantConnect Research Notebook or as an orchestrator using the QuantConnect API:

from AlgorithmImports import *
import csv
import time

# Adjust these with your actual credentials
USER_ID: int = 123456
API_TOKEN: str = "YOUR_API_TOKEN"
PROJECT_ID: int = 999999

# Create a new instance of the QuantConnect API
api = Api()

def run_backtest_for_ticker(ticker: str) -> float:
    """
    Compiles the project, creates a backtest with the specified ticker parameter,
    waits until completion, and returns the Sharpe Ratio.
    """
    # 1) Compile the project
    compile_response = api.create_compile(PROJECT_ID)
    if compile_response is None:
        raise ValueError("No compile response returned.")
    # Check for successful compile
    if compile_response.state != "BuildSuccess":
        errors = compile_response.errors if compile_response.errors else "Unknown compile errors"
        raise ValueError(f"Compile error: {errors}")

    compile_id = compile_response.compile_id
    if not compile_id:
        raise ValueError("CompileId is missing.")

    # 2) Create a backtest
    backtest_name = f"Backtest_{ticker}_{int(time.time())}"
    create_response = api.create_backtest(
        project_id=PROJECT_ID,
        compile_id=compile_id,
        backtest_name=backtest_name,
        parameters={"ticker": ticker}
    )
    if create_response is None or not create_response.backtest_id:
        raise ValueError(f"Failed to create backtest for {ticker}.")

    backtest_id = create_response.backtest_id

    # 3) Poll until the backtest is completed
    while True:
        current_backtest = api.read_backtest(PROJECT_ID, backtest_id)
        if current_backtest is None:
            raise ValueError("Failed to retrieve backtest data during polling.")
        if current_backtest.progress >= 1.0:
            break
        time.sleep(5)

    # 4) Retrieve final backtest data
    final_data = api.read_backtest(PROJECT_ID, backtest_id)
    if final_data is None:
        raise ValueError("Failed to retrieve final backtest data.")

    # 5) Extract the Sharpe Ratio
    sharpe_ratio_str = "0"
    if final_data.statistics and "Sharpe Ratio" in final_data.statistics:
        sharpe_ratio_str = final_data.statistics["Sharpe Ratio"]

    try:
        return float(sharpe_ratio_str)
    except ValueError:
        return 0.0

def main() -> None:
    """
    Reads tickers from 'tickers.csv', runs each backtest in sequence,
    and writes the ticker and Sharpe ratio to 'sharpe_results.csv'.
    """
    # 1) Read tickers file
    tickers: list[str] = []
    try:
        with open("tickers.csv", "r", newline="") as f:
            for line in f:
                symbol = line.strip()
                if symbol:
                    tickers.append(symbol)
    except FileNotFoundError:
        raise FileNotFoundError("tickers.csv file not found in the project directory.")

    # 2) For each ticker, run the backtest, store the Sharpe ratio
    results: list[tuple[str, float]] = []
    for ticker in tickers:
        sharpe_val = run_backtest_for_ticker(ticker)
        results.append((ticker, sharpe_val))

    # 3) Write the results to 'sharpe_results.csv'
    with open("sharpe_results.csv", "w", newline="") as outfile:
        writer = csv.writer(outfile)
        writer.writerow(["ticker", "sharpe_ratio"])
        for tkr, sr in results:
            writer.writerow([tkr, sr])

if __name__ == "__main__":
    main()

Key Notes for Use:

• This script assumes you have a parameterized QCAlgorithm accepting a ticker parameter (likely via self.GetParameter("ticker") in Initialize).
• It programmatically runs one backtest for each ticker, waiting until the current one is complete before proceeding.
• Replace USER_ID, API_TOKEN, and PROJECT_ID with your actual credentials and project ID.
• Results will be written to sharpe_results.csv with columns: ticker,sharpe_ratio.

Let me know if you need help setting up the parameterized algorithm or adjusting any step!

Sources: Backtest Analysis - QuantConnect.com, Probabilistic Sharpe Ratio, Head & Shoulders TA Pattern Detection, Gaussian Naive Bayes Model, Results - QuantConnect.com

Thanks @mia-ai . Can you also please include a simple working example of the main.py file containing parameterized QCAlgorithm accepting a ticker parameter (using self.GetParameter("ticker") in Initialize).

Hello,

I am getting the following error when running the updated script from above in a QuantConnect Research Notebook:

---------------------------------------------------------------------------
NullReferenceException                    Traceback (most recent call last)

Cell In[28], line 20, in run_backtest_for_ticker(ticker)
    18 # 1) Compile the project
    19 print(PROJECT_ID)
---> 20 compile_response = api.create_compile(PROJECT_ID)
    21 if compile_response is None:
    22     raise ValueError("No compile response returned.")

NullReferenceException: Object reference not set to an instance of an object.
  at QuantConnect.Api.Api.CreateCompile(Int32 projectId) in /LeanCloud/CI.Builder/bin/Release/src/QuantConnect/LeanEnterprise/Api/Api.cs:line 434
  at InvokeStub_Api.CreateCompile(Object, Span`1)
  at System.Reflection.MethodBaseInvoker.InvokeWithOneArg(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)

------------------------------------------------------------------------

I am using my own credentials. Am I missing something here?

Thank you!

Hi S Ray

It is likely an API connection issue. I'd suggest you connect the research notebook then wait for a few seconds first. Then, run the code with the API. If the problem persists, please attach a backtest or code snippet for further assistance.

Best
Louis

Thank you