Tag: algorithmic trading

Introduction

Backtesting is a crucial process for algorithmic traders, as it allows them to evaluate the performance of a strategy using historical data. By testing strategies in a simulated environment, traders can gain valuable insights into how their trading algorithm would perform without putting real money at risk. In this article, we will explore how to implement a simple Buy-and-Hold strategy using Lumibot and historical data from Polygon.io. This strategy involves purchasing a single asset and holding it over time, which is ideal for long-term investors.

Polygon.io offers reliable, high-quality financial data for backtesting, including minute-level and daily historical data. Unlike Yahoo Finance, which is limited to daily data, Polygon.io is well-suited for traders looking to backtest strategies with higher-frequency data. In this guide, we’ll use Polygon.io data to backtest a Buy-and-Hold strategy on an asset of your choice and analyze how it performs compared to a benchmark such as the S&P 500.

Let’s dive into the process of setting up Lumibot with Polygon.io data, implementing a Buy-and-Hold strategy, and performing a backtest to evaluate the strategy’s performance.

Implementing the Buy-and-Hold Strategy Using Lumibot and Polygon.io Data

This section explains how to set up and backtest a simple Buy-and-Hold strategy using Polygon.io data with the Lumibot algorithmic trading framework. The strategy buys a single asset and holds it for the entire backtesting period, aiming to simulate long-term investing behavior. Below is a breakdown of the key components of the code.

from datetime import datetime
from lumibot.strategies.strategy import Strategy

"""
Strategy Description

Simply buys one asset and holds onto it.
"""

class BuyAndHold(Strategy):
    parameters = {
        "buy_symbol": "AAPL",  # Change this to the asset symbol of your choice
    }

    # =====Overloading lifecycle methods=============

    def initialize(self):
        # Set the sleep time to one day (the strategy will run once per day)
        self.sleeptime = "1D"

    def on_trading_iteration(self):
        """Buys the self.buy_symbol once, then never again"""

        # Get the current datetime and log it
        dt = self.get_datetime()  # Used to get the time in the backtesting environment
        self.log_message(f"Current datetime: {dt}")

        # Get the symbol to buy from the parameters
        buy_symbol = self.parameters["buy_symbol"]

        # Get the current value of the symbol and log it
        current_value = self.get_last_price(buy_symbol)
        self.log_message(f"The value of {buy_symbol} is {current_value}")

        # Add a line to the indicator chart
        self.add_line(f"{buy_symbol} Value", current_value)

        # Get all the positions that we have
        all_positions = self.get_positions()

        # If we don't own anything (other than USD), buy the asset
        if len(all_positions) <= 1:  # Because we always have a cash position (USD)

            # Calculate the quantity to buy
            quantity = int(self.portfolio_value // current_value)

            # Create the order and submit it
            purchase_order = self.create_order(buy_symbol, quantity, "buy")
            self.submit_order(purchase_order)

Key Components of the Strategy Code

• dt = self.get_datetime(): This method retrieves the current date and time during the backtesting session. It ensures that the trades or actions taken by the algorithm are aligned with specific historical market events.
• self.add_line(f”{buy_symbol} Value”, current_value): This function adds the asset’s price data to a visual chart during backtesting. It tracks the value of the chosen asset over time, providing insight into its performance.
• all_positions = self.get_positions(): This function fetches all current positions held by the strategy, including cash. Since this is a Buy-and-Hold strategy, it checks if the portfolio already contains the chosen asset. If it doesn’t, it buys the asset and holds it throughout the backtesting period.

Backtesting the Strategy with Polygon.io Data

In this section, we’ll cover how to set up the backtest using historical data from Polygon.io. This data source provides more granular historical price data (such as minute-level data), which allows us to simulate the strategy with higher accuracy. Below is the code for setting up and running the backtest.

if __name__ == "__main__":
    IS_BACKTESTING = True

    if IS_BACKTESTING:
        from lumibot.backtesting import PolygonDataBacktesting

        # Backtest this strategy
        backtesting_start = datetime(2023, 1, 1)
        backtesting_end = datetime(2024, 9, 1)

        results = BuyAndHold.run_backtest(
            PolygonDataBacktesting,
            backtesting_start,
            backtesting_end,
            benchmark_asset="SPY",  # Use S&P 500 as a benchmark
        )

        # Print the results
        print(results)
    else:
        POLYGON_CONFIG = {
            "API_KEY": "YOUR_API_KEY",
        }

        from lumibot.brokers import Polygon
        from lumibot.traders import Trader

        trader = Trader()

        broker = Polygon(POLYGON_CONFIG)

        strategy = BuyAndHold(broker=broker)

        trader.add_strategy(strategy)
        strategy_executors = trader.run_all()

Key Points in the Backtesting Code

• IS_BACKTESTING = True: This flag determines whether the script will run in backtesting mode or live trading mode. When True, the strategy will backtest with historical data. In live trading mode, it connects to a real broker and executes live trades.
• PolygonDataBacktesting: This method loads historical price data from Polygon.io. Unlike Yahoo Finance, Polygon.io supports minute-level data, making it suitable for testing short-term strategies. However, in this case, we use daily data for a Buy-and-Hold strategy.
• Backtest Period: The strategy is tested between January 1, 2023, and September 1, 2024. During this period, the performance of the asset will be compared to a benchmark like the S&P 500.

Complete Code

from datetime import datetime
 
from lumibot.strategies.strategy import Strategy
 
"""
Strategy Description
 
Simply buys one asset and holds onto it.
"""
 
 
class BuyAndHold(Strategy):
    parameters = {
        "buy_symbol": "QQQ",
    }
 
    # =====Overloading lifecycle methods=============
 
    def initialize(self):
        # Set the sleep time to one day (the strategy will run once per day)
        self.sleeptime = "1M"
 
    def on_trading_iteration(self):
        """Buys the self.buy_symbol once, then never again"""
 
        # Get the current datetime and log it
        dt = self.get_datetime() # We use this function so that we get the time in teh backtesting environment
        self.log_message(f"Current datetime: {dt}")
 
        # Get the symbol to buy from the parameters
        buy_symbol = self.parameters["buy_symbol"]
 
        # Get the current value of the symbol and log it
        current_value = self.get_last_price(buy_symbol)
        self.log_message(f"The value of {buy_symbol} is {current_value}")
 
        # Add a line to the indicator chart
        self.add_line(f"{buy_symbol} Value", current_value)
 
        # Get all the positions that we have
        all_positions = self.get_positions()
 
        # If we don't own anything (other than USD), buy the asset
        if len(all_positions) <= 1:  # Because we always have a cash position (USD)
 
            # Calculate the quantity to buy
            quantity = int(self.portfolio_value // current_value)
 
            # Create the order and submit it
            purchase_order = self.create_order(buy_symbol, quantity, "buy")
            self.submit_order(purchase_order)
 
 
if __name__ == "__main__":
    IS_BACKTESTING = True
 
    if IS_BACKTESTING:
        from lumibot.backtesting import PolygonDataBacktesting
 
        # Backtest this strategy
        backtesting_start = datetime(2024, 1, 1)
        backtesting_end = datetime(2024, 9, 1)
 
        results = BuyAndHold.run_backtest(
            PolygonDataBacktesting,
            backtesting_start,
            backtesting_end,
            benchmark_asset="SPY",
            polygon_api_key="tYtRp9IBM_t8NbsE6cKGEF33XwlFprCv",
        )
 
        # Print the results
        print(results)
    else:
        ALPACA_CONFIG = {
            "API_KEY": "YOUR_API_KEY",
            "API_SECRET": "YOUR_API_SECRET",
            "PAPER": True,
        }
 
        from lumibot.brokers import Alpaca
        from lumibot.traders import Trader
 
        trader = Trader()
 
        broker = Alpaca(ALPACA_CONFIG)
 
        strategy = BuyAndHold(broker=broker)
 
        trader.add_strategy(strategy)
        strategy_executors = trader.run_all()

Output Files and Key Metrics Explained

Once the backtest is complete, Lumibot generates several important output files. These files contain detailed information about the performance of the strategy, including a tearsheet, indicators, and a trades file. Below is an overview of what each file contains and how to interpret the results.

1. Tearsheet.html / Tearsheet.csv

The tearsheet file provides a comprehensive report on the strategy’s performance, including various metrics that measure profitability and risk. Some key metrics include:

• Total Return: The overall return generated by the strategy during the backtesting period.
• CAGR (Compound Annual Growth Rate): The average annual growth rate over the backtest period.
• Sharpe Ratio: A measure of risk-adjusted return.
• Max Drawdown: The maximum decline in portfolio value from peak to trough.
• Sortino Ratio: A variation of the Sharpe Ratio that penalizes only downside risk.

Output for Polygon.io Backtesting

2. Indicators.html / Indicators.csv

The indicators file records all technical indicators used in the strategy. These values can be reviewed to understand how the strategy reacts to various market conditions.

Output for Polygon.io Backtesting

3. Trades.html / Trades.csv

The trades file logs every trade executed by the strategy during the backtest. It includes data like the trade timestamp, symbol, buy/sell action, trade price, and the profit or loss for each transaction.

Output for Polygon.io Backtesting

Conclusion

By using Polygon.io’s comprehensive data and Lumibot’s robust backtesting framework, we can evaluate the effectiveness of a simple Buy-and-Hold strategy. Polygon.io’s minute-level data is particularly valuable for testing strategies that require more granularity than daily data, making it ideal for a wide range of strategies beyond just long-term investing.

The Buy-and-Hold strategy is a great starting point for understanding backtesting, but you can build more complex strategies using Lumibot and Polygon.io data. Whether you are a beginner or an experienced algorithmic trader, this combination offers the tools and data needed to test and improve your strategies efficiently.

Introduction

Backtesting is an essential part of algorithmic trading that allows traders to simulate a strategy’s performance using historical data. By testing strategies on past market conditions, traders can gain valuable insights into how their approach might behave in real-world scenarios without risking actual capital. One of the simplest yet effective long-term strategies is the Buy-and-Hold approach, where an investor purchases an asset and holds it regardless of market fluctuations. This strategy is favored by investors who believe in the long-term appreciation of the asset’s value.

In this article, we will explore how to implement a Buy-and-Hold strategy using Lumibot, an algorithmic trading framework, and data from Yahoo Finance. Lumibot provides the infrastructure needed to test and deploy strategies, while Yahoo Finance offers a rich source of historical market data. We will backtest the strategy on the QQQ ETF, which tracks the performance of the Nasdaq 100 over a defined period to see how it performs compared to a benchmark like the S&P 500.

Let’s read on to learn how to set up Lumibot, fetch historical data from Yahoo Finance, implement the strategy, and analyze its performance through backtesting. Whether you’re a beginner or an experienced trader, this guide will help you understand the basics of building and testing trading strategies using Python and Lumibot.

Implementing the Buy-and-Hold Strategy Using Lumibot and Yahoo Finance Data

In this section, we will break down the steps involved in implementing and backtesting a simple Buy-and-Hold strategy using Lumibot with Yahoo Finance data. This strategy buys a single asset (in this case, the QQQ ETF) and holds it throughout the entire backtest. We will explain the code, focusing on key components like the get_datetime() function, how to add data to indicator charts, and the backtesting logic.

Strategy Breakdown

The Buy-and-Hold strategy is one of the simplest trading strategies, where an asset is purchased and held over time without selling. Here, we are using Lumibot’s framework to automate this strategy, allowing it to buy the QQQ ETF once and hold it throughout the backtesting period. Below are the key steps and components of the code.

from datetime import datetime
from lumibot.strategies.strategy import Strategy

"""
Strategy Description
Simply buys one asset and holds onto it.
"""

class BuyAndHold(Strategy):
    parameters = {
        "buy_symbol": "QQQ",
    }

    # =====Overloading lifecycle methods=============
    def initialize(self):
        # Set the sleep time to one day (the strategy will run once per day)
        self.sleeptime = "1D"

    def on_trading_iteration(self):
        """Buys the self.buy_symbol once, then never again"""

        # Get the current datetime and log it
        dt = self.get_datetime()  # Used to get the time in the backtesting environment
        self.log_message(f"Current datetime: {dt}")

        # Get the symbol to buy from the parameters
        buy_symbol = self.parameters["buy_symbol"]

        # Get the current value of the symbol and log it
        current_value = self.get_last_price(buy_symbol)
        self.log_message(f"The value of {buy_symbol} is {current_value}")

        # Add a line to the indicator chart
        self.add_line(f"{buy_symbol} Value", current_value)

        # Get all the positions that we have
        all_positions = self.get_positions()

        # If we don't own anything (other than USD), buy the asset
        if len(all_positions) <= 1:  # We always have a cash position (USD)

            # Calculate the quantity to buy
            quantity = int(self.portfolio_value // current_value)

            # Create the order and submit it
            purchase_order = self.create_order(buy_symbol, quantity, "buy")
            self.submit_order(purchase_order)

Key Components

• dt = self.get_datetime(): This method fetches the current datetime within the backtesting environment, allowing the strategy to log or perform actions based on specific times. It’s especially useful when you need to align trades or actions with historical market events.
• self.add_line(f”{buy_symbol} Value”, current_value): This line adds data to the indicator chart for tracking purposes. In this case, it logs the value of the asset (QQQ) over time, allowing you to visually monitor its price movements during the backtest.
• all_positions = self.get_positions(): This retrieves all the positions currently held by the strategy. Since the strategy is designed to buy and hold only one asset (besides cash), we use this to check whether the asset is already in the portfolio. If not, the strategy will purchase it.

Backtesting the Strategy

The backtesting section of the code allows us to simulate how the strategy would have performed over a specific historical period using Yahoo Finance data. Backtesting is crucial to ensure the strategy’s viability without risking real capital.

Backtesting the Strategy

The backtesting section of the code allows us to simulate how the strategy would have performed over a specific historical period using Yahoo Finance data. Backtesting is crucial to ensure the strategy’s viability without risking real capital.

if __name__ == "__main__":
    IS_BACKTESTING = True

    if IS_BACKTESTING:
        from lumibot.backtesting import YahooDataBacktesting

        # Backtest this strategy
        backtesting_start = datetime(2023, 1, 1)
        backtesting_end = datetime(2024, 9, 1)

        results = BuyAndHold.run_backtest(
            YahooDataBacktesting,
            backtesting_start,
            backtesting_end,
            benchmark_asset="SPY",
        )

        # Print the results
        print(results)
    else:
        ALPACA_CONFIG = {
            "API_KEY": "YOUR_API_KEY",
            "API_SECRET": "YOUR_API_SECRET",
            "PAPER": True,
        }

        from lumibot.brokers import Alpaca
        from lumibot.traders import Trader

        trader = Trader()
        broker = Alpaca(ALPACA_CONFIG)

        strategy = BuyAndHold(broker=broker)
        trader.add_strategy(strategy)
        strategy_executors = trader.run_all()

Key Points in the Backtesting Code

• IS_BACKTESTING = True: This flag tells the script whether to run in backtesting mode or live trading mode. In backtesting mode, historical data is used to simulate trades. In live mode, the strategy would execute trades with a real broker.
• Yahoo Finance Data: In backtesting, we use YahooDataBacktesting, which provides daily historical price data. Yahoo Finance supports daily data (not minute-level data), which is why we use a sleep time of 1D in the strategy to run once per day. This is perfect for long-term strategies like Buy-and-Hold, but not suitable for high-frequency or minute-based trading strategies.
• Backtest Period: The strategy is tested between January 1, 2023, and September 1, 2024. During this period, the performance is compared against the S&P 500 benchmark (represented by the symbol SPY).

Complete Code

from datetime import datetime
 
from lumibot.strategies.strategy import Strategy
 
"""
Strategy Description
 
Simply buys one asset and holds onto it.
"""
 
 
class BuyAndHold(Strategy):
    parameters = {
        "buy_symbol": "QQQ",
    }
 
    # =====Overloading lifecycle methods=============
 
    def initialize(self):
        # Set the sleep time to one day (the strategy will run once per day)
        self.sleeptime = "1D"
 
    def on_trading_iteration(self):
        """Buys the self.buy_symbol once, then never again"""
 
        # Get the current datetime and log it
        dt = self.get_datetime() # We use this function so that we get the time in teh backtesting environment
        self.log_message(f"Current datetime: {dt}")
 
        # Get the symbol to buy from the parameters
        buy_symbol = self.parameters["buy_symbol"]
 
        # Get the current value of the symbol and log it
        current_value = self.get_last_price(buy_symbol)
        self.log_message(f"The value of {buy_symbol} is {current_value}")
 
        # Add a line to the indicator chart
        self.add_line(f"{buy_symbol} Value", current_value)
 
        # Get all the positions that we have
        all_positions = self.get_positions()
 
        # If we don't own anything (other than USD), buy the asset
        if len(all_positions) <= 1:  # Because we always have a cash position (USD)
 
            # Calculate the quantity to buy
            quantity = int(self.portfolio_value // current_value)
 
            # Create the order and submit it
            purchase_order = self.create_order(buy_symbol, quantity, "buy")
            self.submit_order(purchase_order)
 
 
if __name__ == "__main__":
    IS_BACKTESTING = True
 
    if IS_BACKTESTING:
        from lumibot.backtesting import YahooDataBacktesting
 
        # Backtest this strategy
        backtesting_start = datetime(2023, 1, 1)
        backtesting_end = datetime(2024, 9, 1)
 
        results = BuyAndHold.run_backtest(
            YahooDataBacktesting,
            backtesting_start,
            backtesting_end,
            benchmark_asset="SPY",
        )
 
        # Print the results
        print(results)
    else:
        ALPACA_CONFIG = {
            "API_KEY": "YOUR_API_KEY",
            "API_SECRET": "YOUR_API_SECRET",
            "PAPER": True,
        }
 
        from lumibot.brokers import Alpaca
        from lumibot.traders import Trader
 
        trader = Trader()
 
        broker = Alpaca(ALPACA_CONFIG)
 
        strategy = BuyAndHold(broker=broker)
 
        trader.add_strategy(strategy)
        strategy_executors = trader.run_all()

Output Files and Key Metrics Explained: Tearsheet, Indicators, and Trades

When backtesting a strategy using Lumibot, the results are compiled into several detailed output files. These files help traders analyze the performance of their strategy, both in terms of profitability and risk. Below is an explanation of the key output files—tearsheet.html, indicators.html/csv, and trades.html/csv—along with an in-depth look at important metrics commonly found in the tearsheet.

1. Tearsheet.html / Tearsheet.csv

The tearsheet is the primary report generated from a backtest, summarizing the strategy’s overall performance across various dimensions. It contains critical metrics that give insight into returns, risk, and consistency. Let’s break down some of the key metrics:

Key Performance Metrics in Tearsheet:

• Risk-Free Rate:
  • The theoretical return on an investment with zero risk, often based on government bond yields. This is used to calculate risk-adjusted metrics like the Sharpe and Sortino Ratios.
• Time in Market:
  • The percentage of time that the strategy was actively holding a position in the market during the backtest period. This shows how much of the time the strategy had exposure to the market.
• Total Return:
  • The overall return the strategy achieved over the entire backtest period. It’s a simple percentage that represents how much your portfolio grew from start to finish.
• CAGR (Compound Annual Growth Rate) %:
  • The average annual growth rate of the investment over the backtesting period, assuming the profits are reinvested each year. It gives a clearer picture of the strategy’s long-term growth potential.
• ROMAD (Return Over Maximum Drawdown):
  • A performance metric that measures the return earned per unit of maximum drawdown (the worst drop in portfolio value). A higher ROMAD indicates better performance relative to the strategy’s worst downturn.
• Correlation to Benchmark:
  • This metric shows how closely the strategy’s returns are correlated to the benchmark index (e.g., S&P 500). A correlation closer to 1 means the strategy moves similarly to the benchmark, while a value closer to 0 means the strategy behaves independently.
• Sortino Ratio:
  • A risk-adjusted return metric that focuses only on downside risk (negative volatility). It is similar to the Sharpe Ratio but penalizes only those returns that fall below a specific threshold (usually the risk-free rate).
• Max Drawdown:
  • The largest peak-to-trough decline in portfolio value during the backtesting period. It shows the most significant loss the strategy experienced and is crucial for assessing risk tolerance.
• Maximum Drawdown Days:
  • The number of days it took for the strategy to recover from its maximum drawdown. This shows how long the portfolio was underwater before it reached its previous peak.
• Minimum Volatility:
  • The lowest level of volatility (price fluctuation) experienced by the strategy during the backtest period. Lower volatility generally indicates a smoother, less risky strategy.

Win/Loss Metrics:

These metrics help assess how often the strategy outperforms over different timeframes:

• Win Days %:
  • The percentage of days where the strategy generated a positive return. This metric helps evaluate the consistency of the strategy on a day-to-day basis.
• Win Months %:
  • The percentage of months where the strategy was profitable. This gives insight into the strategy’s long-term consistency.
• Win Quarters %:
  • The percentage of quarters where the strategy showed gains. Winning in most quarters indicates strong and consistent performance.
• Win Years %:
  • The percentage of years where the strategy was profitable. A high win percentage over years indicates a robust long-term strategy.

Below is the tearsheet.html  for the above code:

2. Indicators.html / Indicators.csv

The indicators file records various technical indicators used in the strategy during the backtest. These indicators help you track how market conditions evolved and how your strategy responded based on predefined rules. The data is typically logged at each time step (daily, weekly, etc.), providing a clear view of the key metrics that influence trading decisions.

Key Contents of Indicators File:

• Indicator Values Over Time:
  • This might include moving averages, RSI, MACD, Bollinger Bands, or other indicators the strategy uses. You can see how these values fluctuate over time and correlate to the strategy’s buy/sell actions.
• Custom Strategy Metrics:
  • If the strategy logs custom values (like portfolio value, cash position, or specific thresholds), they will also appear in this file.

Below is the indicator.html  file for the above code:

This file is particularly helpful for understanding how the strategy reacts to changing market conditions and whether the signals generated by indicators are being used effectively.

3. Trades.html / Trades.csv

The trades file records every trade executed by the strategy during the backtest. This detailed log helps you analyze each transaction to see if the strategy performed as expected. It provides transparency into when and why trades were made.

Key Contents of Trades File:

• Trade Timestamp:
  • The date and time when each trade was executed.
• Symbol:
  • The asset being traded (e.g., QQQ).
• Buy/Sell Action:
  • Indicates whether the trade was a buy or sell order.
• Trade Price:
  • The price at which the asset was bought or sold.
• Quantity:
  • The number of units (e.g., shares or contracts) involved in the trade.
• Profit/Loss:
  • The resulting profit or loss from each trade. This helps you identify which trades were successful and which weren’t.
• Order Type:
  • Whether the order was a market, limit, or other type of order.

Below is the traders.html file for the above code:

This file allows you to do a deep dive into the mechanics of the strategy. By reviewing the trades, you can verify that the strategy was executing properly, and identify patterns in profitable and unprofitable trades.

Conclusion

This strategy and backtest allow us to evaluate how a simple Buy-and-Hold approach performs over time using Lumibot and Yahoo Finance data. While the strategy only buys one asset and holds it, backtesting on historical data provides crucial insights into its performance against benchmarks like the S&P 500.

By leveraging Lumibot, you can further customize this strategy or explore more complex trading strategies. Yahoo Finance data works best for daily strategies, making it ideal for long-term investments rather than short-term or high-frequency trades.