Beat the Market: An Effective Intraday Momentum Strategy for S&P500 ETF (SPY)

Based on the provided Python code, there are a few potential issues that might be causing problems:

1. The self._vwap is initialized but never updated with new data. You might want to update it in the consolidate method.

2. The long_stop_price is calculated but never used. If it's supposed to be a stop price for long positions, you might want to implement logic that uses this value to exit long positions.

3. The self._deviation indicator is updated with the entire bar object, but it might be expecting a specific value like bar.close. Make sure to pass the correct data to the indicator's update method.

4. The consolidate method doesn't handle the case when self._vol is not ready or self.previous_close is None. You might want to add logic to handle these cases.

5. The end_of_day method is scheduled to be called every day before the market close, but it's not implemented in the provided code. You should implement this method if it's necessary for your strategy.

Remember, these are just potential issues based on the provided code. The actual issues might be different depending on the rest of your code and your specific strategy.

Here is the relevant part of the code with the potential issues:

def consolidate(self, sender, bar):
    current_date = bar.end_time.date()
    self.bars.append(bar)
    if current_date != self.previous_date:
        self.previous_date = current_date
        self.open_price = bar.open
        self.previous_close = self.bars[-2].close if len(self.bars) == 2 else None
    self._deviation.update(bar)
    if not self._vol.is_ready or not self.previous_close:
        return
    upper_band = (max(self.open_price, self.previous_close) * (1 + self._deviation.value))
    lower_band = (min(self.open_price, self.previous_close) * (1 - self._deviation.value))
    vwap_price = self._vwap.current.value
    long_stop_price = np.max([vwap_price, upper_band])

Please review your code and make sure everything is implemented correctly. If you're still having issues, you might want to consider asking for help on the QuantConnect forum.

The attached backtest provides a way to implement the strategy across a portfolio of assets

Based on the provided Python code, there are a few potential issues that might be causing problems:

1. The security._vwap is initialized but never updated with new data. You might want to update it in the consolidate_handler method.

2. The long_stop_price and short_stop_price are calculated but never used. If they're supposed to be stop prices for long and short positions, you might want to implement logic that uses these values to exit positions.

3. The security._deviation indicator is updated with the entire bar object, but it might be expecting a specific value like bar.close. Make sure to pass the correct data to the indicator's update method.

4. The consolidate_handler method doesn't handle the case when security._vol is not ready, security._previous_close is None, or security._deviation is not ready. You might want to add logic to handle these cases.

5. The end_of_day method is scheduled to be called every day before the market close, but it's not implemented in the provided code. You should implement this method if it's necessary for your strategy.

6. The vol_target variable is defined but never used. If it's supposed to be a target for position sizing, you might want to implement logic that uses this value to size positions.

Remember, these are just potential issues based on the provided code. The actual issues might be different depending on the rest of your code and your specific strategy.

Here is the relevant part of the code with the potential issues:

def consolidate_handler(self, bar):
    symbol = bar.symbol
    security = self.securities[symbol]
    current_date = bar.end_time.date()
    security._bars.append(bar)
    if current_date != security._previous_date:
        security._previous_date = current_date
        security._open_price = bar.open
        security._previous_close = security._bars[-2].close if len(security._bars) == 2 else None
    security._deviation.update(bar)
    if not security._vol.is_ready or not security._previous_close or not security._deviation.ready:
        return
    upper_band = (max(security._open_price, security._previous_close) * (1 + security._deviation.value))
    lower_band = (min(security._open_price, security._previous_close) * (1 - security._deviation.value))
    vwap_price = security._vwap.current.value
    long_stop_price = np.max([vwap_price, upper_band])
    short_stop_price = np.min([vwap_price, lower_band])
    is_up_trend = bar.close > security._vwap.current.value
    is_down_trend = bar.close < security._vwap.current.value
    is_long = self.portfolio[symbol].is_long
    is_short = self.portfolio[symbol].is_short
    is_long_stopped_out = is_long and bar.close <= long_stop_price
    is_short_stopped_out = is_short and bar.close >= short_stop_price
    is_not_last_trade_date = security._last_trade_date != current_date
    vol_target = 0.02

Please review your code and make sure everything is implemented correctly. If you're still having issues, you might want to consider asking for help on the QuantConnect forum.

Hi Flame,

I know it's been a while since you posted this. I have taken a shot at this algorithm and compared your QuantConnect implementation with the authors python implementation that they gratefully shared:

I compared trade by trade on a couple days. From what I can tell your algo runs as intended, but at QuantConnect the real bid/ask spread is considered compared to the authors backtest, which is a drag on the results. I tried to simulate “no spread” on QuantConnect and got almost the same performance as in the paper as a result.
Speaking of almost, the daily open/close prices of SPY seem to deviate a couple cents between different data sources which leads to trades firing a little different.

I would be glad to connect to talk about this algo, it's been a while, have people around here successfully traded with it? The authors added a section to their paper that an implementation with futures works as well, for example.

Best Regards
Nico