Volatility Oscillator Divergence Trading Strategy with ATR-Based Risk Management

This article describes a trading strategy implemented in Backtrader that identifies divergence between price movements and volatility oscillator changes to generate trade signals. The strategy combines trend confirmation, volatility-adjusted position sizing, and ATR-based trailing stops to capitalize on potential reversals or continuations in trending markets.

Strategy Overview

The Volatility Oscillator Divergence Trading Strategy includes the following components:

• Volatility Oscillator: Measures the rate of change (ROC) of 20-day volatility over 5 days to detect shifts in market activity.
• Price Divergence: Compares recent price changes to volatility oscillator changes to identify bullish or bearish divergences.
• Trend Confirmation: Uses a 30-day Simple Moving Average (SMA) to ensure trades align with the broader market trend.
• RSI Filter: Incorporates a 14-day Relative Strength Index (RSI) to avoid overbought (RSI > 70) or oversold (RSI < 30) conditions.
• Position Sizing: Adjusts trade size based on the Average True Range (ATR) relative to price, ranging from 20% to 80% of available cash.
• Risk Management: Implements ATR-based trailing stops (3x ATR) and a maximum holding period of 30 bars to limit risk.
• Trade Spacing: Enforces a minimum gap of 1 bar between trades to avoid overtrading.

Code Implementation

Below is the complete Backtrader code for the strategy:

import backtrader as bt
import numpy as np

class VolatilityOscillatorDivergenceStrategy(bt.Strategy):
    params = (
        ('vol_window', 20),
        ('vol_roc_period', 5),
        ('price_lookback', 5),
        ('sma_period', 30),
        ('atr_period', 14),
        ('atr_multiplier', 3.0),
        ('rsi_period', 14),
        ('max_hold_bars', 30),
        ('min_gap_bars', 1),
    )
    
    def __init__(self):
        self.returns = bt.indicators.PctChange(period=1)
        self.volatility = bt.indicators.StdDev(self.returns, period=self.params.vol_window)
        self.vol_osc = bt.indicators.ROC(self.volatility, period=self.params.vol_roc_period)
        self.sma = bt.indicators.SMA(period=self.params.sma_period)
        self.atr = bt.indicators.ATR(period=self.params.atr_period)
        self.rsi = bt.indicators.RSI(period=self.params.rsi_period)
        
        self.entry_bar = None
        self.last_trade_bar = None
        self.stop_price = None
        
    def next(self):
        if len(self.data) < 50:
            return
            
        current_price = self.data.close[0]
        
        # Exit on hold limit
        if self.position and self.entry_bar:
            if (len(self.data) - self.entry_bar) >= self.params.max_hold_bars:
                self.close()
                self.entry_bar = None
                self.last_trade_bar = len(self.data)
                return
        
        # Exit on trailing stop
        if self.position and self.stop_price:
            if self.position.size > 0 and current_price <= self.stop_price:
                self.close()
                self.entry_bar = None
                self.last_trade_bar = len(self.data)
                return
            elif self.position.size < 0 and current_price >= self.stop_price:
                self.close()
                self.entry_bar = None
                self.last_trade_bar = len(self.data)
                return
        
        # Update trailing stop
        if self.position:
            if self.position.size > 0:
                new_stop = current_price - self.params.atr_multiplier * self.atr[0]
                if self.stop_price is None or new_stop > self.stop_price:
                    self.stop_price = new_stop
            else:
                new_stop = current_price + self.params.atr_multiplier * self.atr[0]
                if self.stop_price is None or new_stop < self.stop_price:
                    self.stop_price = new_stop
        
        # Check minimum gap
        if self.last_trade_bar and (len(self.data) - self.last_trade_bar) < self.params.min_gap_bars:
            return
        
        # Entry signals
        if not self.position:
            price_change = self.data.close[0] - self.data.close[-self.params.price_lookback]
            vol_osc_change = self.vol_osc[0] - self.vol_osc[-self.params.price_lookback]
            
            # Volatility-adjusted position size
            atr_pct = self.atr[0] / current_price
            size_factor = min(0.8, max(0.2, 0.1 / atr_pct)) if atr_pct > 0 else 0.5
            cash = self.broker.getcash()
            size = int(cash * size_factor / current_price)
            
            # Bullish divergence: price up + vol osc down + uptrend + RSI not overbought
            if (price_change > 0 and vol_osc_change < 0 and 
                current_price > self.sma[0] and self.rsi[0] < 70 and size > 0):
                self.buy(size=size)
                self.stop_price = current_price - self.params.atr_multiplier * self.atr[0]
                self.entry_bar = len(self.data)
                self.last_trade_bar = len(self.data)
                
            # Bearish divergence: price down + vol osc up + downtrend + RSI not oversold
            elif (price_change < 0 and vol_osc_change > 0 and 
                  current_price < self.sma[0] and self.rsi[0] > 30 and size > 0):
                self.sell(size=size)
                self.stop_price = current_price + self.params.atr_multiplier * self.atr[0]
                self.entry_bar = len(self.data)
                self.last_trade_bar = len(self.data)

Strategy Explanation

1. VolatilityOscillatorDivergenceStrategy

The strategy identifies divergences between price and volatility oscillator movements to generate trade signals, with risk management and trend confirmation:

• Indicators:

  • Returns: Calculates 1-day percentage returns of the closing price.
  • Volatility: Measures the 20-day standard deviation of returns.
  • Volatility Oscillator: Computes the 5-day Rate of Change (ROC) of the volatility to detect shifts in market activity.
  • SMA: Uses a 30-day Simple Moving Average to confirm the market trend.
  • ATR: Calculates the 14-day Average True Range for trailing stops and position sizing.
  • RSI: Uses a 14-day Relative Strength Index to filter out overbought (RSI > 70) or oversold (RSI < 30) conditions.

• Trading Logic (next):

  • Data Check: Requires 50 days of data to ensure indicator stability.
  • Exit Conditions:
    • Maximum Hold Period: Closes positions after 30 bars to limit exposure.
    • Trailing Stop:
      • For long positions: Exits if the price falls below the stop (current price minus 3x ATR).
      • For short positions: Exits if the price rises above the stop (current price plus 3x ATR).
    • Updates the trailing stop to lock in profits as the price moves favorably.
  • Trade Spacing: Ensures at least 1 bar between trades to avoid rapid re-entries.
  • Entry Conditions:
    • Bullish Divergence:
      • Price increases over 5 days (price_change > 0).
      • Volatility oscillator decreases over 5 days (vol_osc_change < 0).
      • Current price is above the 30-day SMA (uptrend).
      • RSI is below 70 (not overbought).
      • Enters a long position with an ATR-based stop.
    • Bearish Divergence:
      • Price decreases over 5 days (price_change < 0).
      • Volatility oscillator increases over 5 days (vol_osc_change > 0).
      • Current price is below the 30-day SMA (downtrend).
      • RSI is above 30 (not oversold).
      • Enters a short position with an ATR-based stop.
  • Position Sizing: Adjusts size based on ATR as a percentage of price (atr_pct):
    • Size factor ranges from 20% to 80% of cash, inversely proportional to ATR.
    • Calculates shares as cash * size_factor / current_price.

• Tracking:

  • Records the entry bar and last trade bar to enforce holding limits and trade gaps.
  • Maintains the stop price for trailing stops.

Key Features

• Divergence Detection: Capitalizes on mismatches between price and volatility oscillator movements, indicating potential reversals or continuations.
• Trend Confirmation: Uses SMA to align trades with the market trend, reducing false signals.
• RSI Filter: Avoids entries in overbought or oversold conditions for better trade timing.
• Volatility-Adjusted Sizing: Scales position size inversely with ATR to manage risk in volatile markets.
• Risk Management: Combines ATR-based trailing stops and a 30-bar holding limit to control exposure.
• Trade Discipline: Enforces a minimum gap between trades to prevent overtrading.

Potential Improvements

• Parameter Tuning: Optimize vol_window, vol_roc_period, sma_period, or atr_multiplier for specific assets.
• Additional Filters: Incorporate volume or momentum indicators to confirm divergences.
• Fixed Stop-Loss: Add a fixed percentage stop-loss alongside trailing stops for extra protection.
• Multi-Asset Testing: Apply the strategy to multiple assets to diversify risk and assess robustness.

This strategy is designed for markets with periodic divergences between price and volatility, such as stocks or cryptocurrencies, and can be backtested to evaluate performance across various timeframes and assets.