📉Backtest Equity Trading with SMA Strategy

Buy and hold investing on the S&P 500 index with a low cost mutual fund is a top performing system; it can be straightforward relative to many other prevailing techniques employed by many top HF's.

In the below analysis, we'll use a simple moving average strategy and ultimately determine whether it outperforms a buy and hold strategy investing over the course of 20 years. We'll use the The 200 day simple moving average of the the S&P 500 using the SPY ETF and hold if the month-end price is over the 200 day simple moving average (SMA) thereshold. Conversely, we'll sell if the SPY price was under the 200 day SMA on the last day of the month. The end of month signal will avoid all the intra-month false signals when price chops under and over the threshold. This is not the pinnacle of trend trading strategies, however it can provide a fundamental & solid approach to trading equities.

A backtest is a historical simulation of how a strategy would have performed should it have been run over a past period of time.To test our above hypothesis, we'll backtest this SMA Strategy on the SPY over the past 20 years. As indicated above, since we're testing it on the S&P500, we'll use the SPDR S&P 500 Trust ETF which is represented by the ticker SPY. We'll use the yfinance module to get some simple data and feed it to our startegy to get going.

import yfinance
data = yfinance.download("SPY", start="2000-01-01", end="2021-06-16")
data.to_csv("spy.csv")

spy.csv

Buy-Hold backtesting

#backtest-buyhold
from pyalgotrade import strategy
from pyalgotrade.barfeed import yahoofeed

class BuyAndHoldStrategy(strategy.BacktestingStrategy):

    def __init__(self, feed, instrument):
        super(BuyAndHoldStrategy, self).__init__(feed)
        self.instrument = instrument
        self.setUseAdjustedValues(True)
        self.position = None #<-- Trading positions

    def onEnterOk(self, position):
        self.info(f"{position.getEntryOrder().getExecutionInfo()}")
    
    def onBars(self, bars):
        bar = bars[self.instrument]

        if self.position is None:
            close = bar.getAdjClose() #--> Adjusts for dividends & splits
            broker = self.getBroker()
            cash = broker.getCash()
            quantity = cash / close

            self.position = self.enterLong(self.instrument, quantity)

feed = yahoofeed.Feed()
feed.addBarsFromCSV("spy", "spy.csv")

strategy = BuyAndHoldStrategy(feed, "spy")
cash = strategy.getBroker().getCash()
print(f"Initial Cash: ${cash}")
strategy.run()

strategy.run()
portfolio_value = strategy.getBroker().getEquity() + strategy.getBroker().getCash()
print(f"Ending Portfolio Value: ${portfolio_value}")

change_percentage = ((portfolio_value - cash)/cash)*100
print(f"% change: {round(change_percentage,2)}%")

We initally had a default value of $1million of Cash. We can observe that the amount of cash we initially dispensed was $986,838 . (1028 * 95.92...) thereby leaving us some remaining cash. In the aftermath of the Buy-hold strategy, our portfolio value is $2,916,764 representing a total increase of 191.68% which is commendable.

Moving-Average Backtesting

We'll now implement the 200 Day SMA average in order to contrast the results with the above and determine which of these method can generate a greater alpha.

import pandas
import pandas_market_calendars as market_calendar

from pyalgotrade import strategy
from pyalgotrade.barfeed import yahoofeed
from pyalgotrade.technical import ma
from pyalgotrade import plotter
from pyalgotrade.stratanalyzer import returns, drawdown, trades

Note that one of the rules that we have to take into account is the end of the month rule. In the above Buy-Hold strategy, we were looping bar by bar and continually making a decision at each bar iteration. Using this approach, we only want to make a decision if and only it is the last day of the month. Determining the last trading day of the month can actually be a non-trivial as it may potential fall January 31st, February 28th, February 29th on a leap year, market holidays etc. We'll use the import pandas_market_calendars coupled with the below 5 lines of code to take care of these specificities.

# get last days of month
nyse = market_calendar.get_calendar('NYSE')
df = nyse.schedule(start_date='2000-01-01', end_date='2021-12-31')
df = df.groupby(df.index.strftime('%Y-%m')).tail(1)
df['date'] = pandas.to_datetime(df['market_open']).dt.date
last_days_of_month = [date.isoformat() for date in df['date'].tolist()]

class MovingAverageStrategy(strategy.BacktestingStrategy):
    def __init__(self, feed, instrument):
        super(MovingAverageStrategy, self).__init__(feed)
        self.instrument = instrument
        self.position = None
        self.ma = ma.SMA(feed[instrument].getAdjCloseDataSeries(), 200)
        self.setUseAdjustedValues(True)

    def onEnterOk(self, position):
        execInfo = position.getEntryOrder().getExecutionInfo()
        self.info(f"===== BUY at {execInfo.getPrice()} {execInfo.getQuantity()} =====")

    def onExitOk(self, position):
        execInfo = position.getExitOrder().getExecutionInfo()
        self.info(f"===== SELL at {execInfo.getPrice()} =====")
        self.position = None

In the below, note how we're only using 98% of our cash. We're only using 98% to ensure that we have sufficent cash to fill our order. Additionally, in a scenario that we would want to keep hold of half of our "cash", we would pass in 0.50.

def onBars(self, bars):
        if self.ma[-1] is None:
            return

        bar = bars[self.instrument]
        close = bar.getAdjClose()
        date = bar.getDateTime().date().isoformat()

        if date in last_days_of_month:
            if self.position is None:
                broker = self.getBroker()
                cash = broker.getCash() * .98
                
                if date in last_days_of_month and close > self.ma[-1]:
                    quantity = cash / close
                    self.info(f"buying at {close}, which is above {self.ma[-1]}")
                    self.position = self.enterLong(self.instrument, quantity)
            
            elif close < self.ma[-1] and self.position is not None:
                self.info(f"selling at {close}, which is below {self.ma[-1]}")
                self.position.exitMarket()
                self.position = None


# # Load the bar feed from the CSV file
feed = yahoofeed.Feed()
feed.addBarsFromCSV("spy", "spy.csv")

strategy = MovingAverageStrategy(feed, "spy")

returnsAnalyzer = returns.Returns()
tradesAnalyzer = trades.Trades()
drawDownAnalyzer = drawdown.DrawDown()

strategy.attachAnalyzer(returnsAnalyzer)
strategy.attachAnalyzer(drawDownAnalyzer)
strategy.attachAnalyzer(tradesAnalyzer)

plt = plotter.StrategyPlotter(strategy) 
plt.getInstrumentSubplot("spy").addDataSeries("200 day", strategy.ma)

strategy.run()

plt.plot()

print("Final portfolio value: $%.2f" % strategy.getResult())
print("Cumulative returns: %.2f %%" % (returnsAnalyzer.getCumulativeReturns()[-1] * 100))
print("Max. drawdown: %.2f %%" % (drawDownAnalyzer.getMaxDrawDown() * 100))
print("Longest drawdown duration: %s" % (drawDownAnalyzer.getLongestDrawDownDuration()))

print("")
print("Total trades: %d" % (tradesAnalyzer.getCount()))
if tradesAnalyzer.getCount() > 0:
    profits = tradesAnalyzer.getAll()
    print("Avg. profit: $%2.f" % (profits.mean()))
    print("Profits std. dev.: $%2.f" % (profits.std()))
    print("Max. profit: $%2.f" % (profits.max()))
    print("Min. profit: $%2.f" % (profits.min()))
    returns = tradesAnalyzer.getAllReturns()
    print("Avg. return: %2.f %%" % (returns.mean() * 100))
    print("Returns std. dev.: %2.f %%" % (returns.std() * 100))
    print("Max. return: %2.f %%" % (returns.max() * 100))
    print("Min. return: %2.f %%" % (returns.min() * 100))

print("")
print("Profitable trades: %d" % (tradesAnalyzer.getProfitableCount()))
if tradesAnalyzer.getProfitableCount() > 0:
    profits = tradesAnalyzer.getProfits()
    print("Avg. profit: $%2.f" % (profits.mean()))
    print("Profits std. dev.: $%2.f" % (profits.std()))
    print("Max. profit: $%2.f" % (profits.max()))
    print("Min. profit: $%2.f" % (profits.min()))
    returns = tradesAnalyzer.getPositiveReturns()
    print("Avg. return: %2.f %%" % (returns.mean() * 100))
    print("Returns std. dev.: %2.f %%" % (returns.std() * 100))
    print("Max. return: %2.f %%" % (returns.max() * 100))
    print("Min. return: %2.f %%" % (returns.min() * 100))

print("")
print("Unprofitable trades: %d" % (tradesAnalyzer.getUnprofitableCount()))
if tradesAnalyzer.getUnprofitableCount() > 0:
    losses = tradesAnalyzer.getLosses()
    print("Avg. loss: $%2.f" % (losses.mean()))
    print("Losses std. dev.: $%2.f" % (losses.std()))
    print("Max. loss: $%2.f" % (losses.min()))
    print("Min. loss: $%2.f" % (losses.max()))
    returns = tradesAnalyzer.getNegativeReturns()
    print("Avg. return: %2.f %%" % (returns.mean() * 100))
    print("Returns std. dev.: %2.f %%" % (returns.std() * 100))
    print("Max. return: %2.f %%" % (returns.max() * 100))
    print("Min. return: %2.f %%" % (returns.min() * 100))

output 1.1

output 1.2

output 1.3

We can see that by employing this strategy, our final portfolio value equates $6.5mil with an overall increase of 554.94% from our initial cash value thereby surpassing the 191.68% performance of the S&P500 <-> Buy&Hold Strategy over the last 20years. From 2003 to 2007, we were able to capture a huge upswing in the markets(output 1.1) and adjacently we were also able to avoid some of the major drawdowns in the market. As illustrated above (output 1.3), our maximum drawdown was 22.44% sparing us the 50% drawdown of the bear market of 2007-2009 since we had sold our position on 12-31-2007. Similarly, with the coronavirus pandemic which sent equity markets reeling as the S&P500 plummeted 51%, our trading algorithm was able to evade the eye of this crisis as we exited on 02-28-2020.

Overall, quite interesting to observe how splendid our simple startegy performed (No machine learning needed). It'd be very interesting to backtest some learning algorithms and see how they fare against this simple yet solid strategy.

GitHub - SebasIvan26/SMA-Backtesting: Backtest SMA Strategy on the SPY over the past 20 years vs Buy Hold StrategyGitHub

References: https://www.newtraderu.com/2019/10/05/moving-average-trading-strategy-that-crushes-buy-and-hold/