#!/usr/bin/env python3 """ Market Regime Detection System Identifies trending vs ranging markets and provides regime-adaptive trading parameters """ import pandas as pd import numpy as np from enum import Enum from typing import Dict, List, Tuple, Optional import warnings warnings.filterwarnings('ignore') class MarketRegime(Enum): """Market regime classifications""" STRONG_BULL = "strong_bull" BULL_TREND = "bull_trend" BEAR_TREND = "bear_trend" STRONG_BEAR = "strong_bear" RANGING = "ranging" HIGH_VOLATILITY = "high_volatility" LOW_VOLATILITY = "low_volatility" class RegimeParameters: """Trading parameters optimized for each market regime""" def __init__(self): # Base parameters for each regime self.regime_params = { MarketRegime.STRONG_BULL: { 'profit_targets': [0.015, 0.03, 0.06, 0.12], # Higher targets in strong trends 'trailing_stop_pct': 0.03, # Tighter stops to capture momentum 'position_size_multiplier': 1.5, # Larger positions in strong trends 'max_holding_time': 48, # Longer holding in trends 'breakeven_trigger': 0.02, # Later breakeven 'min_confidence_threshold': 0.25, # Lower threshold for strong trends }, MarketRegime.BULL_TREND: { 'profit_targets': [0.012, 0.025, 0.05, 0.10], 'trailing_stop_pct': 0.025, 'position_size_multiplier': 1.2, 'max_holding_time': 36, 'breakeven_trigger': 0.018, 'min_confidence_threshold': 0.3, }, MarketRegime.BEAR_TREND: { 'profit_targets': [0.012, 0.025, 0.05, 0.10], 'trailing_stop_pct': 0.025, 'position_size_multiplier': 1.2, 'max_holding_time': 36, 'breakeven_trigger': 0.018, 'min_confidence_threshold': 0.3, }, MarketRegime.STRONG_BEAR: { 'profit_targets': [0.015, 0.03, 0.06, 0.12], 'trailing_stop_pct': 0.03, 'position_size_multiplier': 1.5, 'max_holding_time': 48, 'breakeven_trigger': 0.02, 'min_confidence_threshold': 0.25, }, MarketRegime.RANGING: { 'profit_targets': [0.008, 0.015, 0.03, 0.06], # Lower targets in ranging markets 'trailing_stop_pct': 0.02, # Tighter stops to protect against whipsaws 'position_size_multiplier': 0.7, # Smaller positions in ranging markets 'max_holding_time': 12, # Shorter holding periods 'breakeven_trigger': 0.012, # Earlier breakeven 'min_confidence_threshold': 0.4, # Higher threshold for ranging markets }, MarketRegime.HIGH_VOLATILITY: { 'profit_targets': [0.02, 0.04, 0.08, 0.15], # Higher targets for volatility 'trailing_stop_pct': 0.04, # Wider stops for volatility 'position_size_multiplier': 0.6, # Smaller positions in high volatility 'max_holding_time': 8, # Very short holding periods 'breakeven_trigger': 0.025, # Later breakeven for volatility 'min_confidence_threshold': 0.5, # Much higher threshold }, MarketRegime.LOW_VOLATILITY: { 'profit_targets': [0.005, 0.01, 0.02, 0.04], # Lower targets in low volatility 'trailing_stop_pct': 0.015, # Tighter stops 'position_size_multiplier': 1.0, # Normal positions 'max_holding_time': 24, # Normal holding periods 'breakeven_trigger': 0.008, # Earlier breakeven 'min_confidence_threshold': 0.35, # Moderate threshold } } def get_parameters(self, regime: MarketRegime) -> Dict: """Get trading parameters for a specific regime""" return self.regime_params.get(regime, self.regime_params[MarketRegime.RANGING]) class MarketRegimeDetector: """ Advanced market regime detection using multiple indicators """ def __init__(self, lookback_periods: List[int] = [20, 50, 100]): self.lookback_periods = lookback_periods self.regime_history = [] self.parameters = RegimeParameters() def detect_regime(self, price_data: pd.DataFrame, current_idx: int = -1) -> Tuple[MarketRegime, Dict]: """ Detect current market regime using comprehensive analysis Args: price_data: DataFrame with OHLC and technical indicators current_idx: Current index in the data (default: latest) Returns: Tuple of (detected_regime, regime_parameters) """ if len(price_data) < max(self.lookback_periods): return MarketRegime.RANGING, self.parameters.get_parameters(MarketRegime.RANGING) # Extract current window if current_idx == -1: current_idx = len(price_data) - 1 # Calculate regime indicators trend_strength = self._calculate_trend_strength(price_data, current_idx) volatility = self._calculate_volatility(price_data, current_idx) momentum = self._calculate_momentum(price_data, current_idx) volume_trend = self._calculate_volume_trend(price_data, current_idx) # Determine primary regime regime = self._classify_regime(trend_strength, volatility, momentum, volume_trend) # Get regime-specific parameters regime_params = self.parameters.get_parameters(regime) # Store regime history self.regime_history.append({ 'timestamp': price_data.index[current_idx] if hasattr(price_data.index, '__getitem__') else current_idx, 'regime': regime, 'trend_strength': trend_strength, 'volatility': volatility, 'momentum': momentum }) return regime, regime_params def _calculate_trend_strength(self, data: pd.DataFrame, idx: int) -> float: """Calculate trend strength using ADX-like indicator""" if 'High' not in data.columns or 'Low' not in data.columns or 'Close' not in data.columns: # Fallback for data without OHLC if 'Close' in data.columns: prices = data['Close'].iloc[max(0, idx-50):idx+1] if len(prices) > 10: # Simple trend strength based on slope x = np.arange(len(prices)) slope = np.polyfit(x, prices.values, 1)[0] return abs(slope) / prices.std() # Normalized slope return 0.0 # Calculate True Range high = data['High'].iloc[max(0, idx-50):idx+1] low = data['Low'].iloc[max(0, idx-50):idx+1] close = data['Close'].iloc[max(0, idx-50):idx+1] tr = np.maximum(high - low, np.maximum(abs(high - close.shift(1)), abs(low - close.shift(1)))) # Calculate Directional Movement dm_plus = np.where((high - high.shift(1)) > (low.shift(1) - low), np.maximum(high - high.shift(1), 0), 0) dm_minus = np.where((low.shift(1) - low) > (high - high.shift(1)), np.maximum(low.shift(1) - low, 0), 0) # Convert to pandas Series for rolling operations dm_plus_series = pd.Series(dm_plus, index=high.index) dm_minus_series = pd.Series(dm_minus, index=high.index) tr_series = pd.Series(tr, index=high.index) # Smooth with Wilder's smoothing atr = tr_series.rolling(14).mean() di_plus = 100 * (dm_plus_series.rolling(14).mean() / atr) di_minus = 100 * (dm_minus_series.rolling(14).mean() / atr) # ADX (trend strength) dx = 100 * abs(di_plus - di_minus) / (di_plus + di_minus) adx = dx.rolling(14).mean() return adx.iloc[-1] if not adx.empty else 0.0 def _calculate_volatility(self, data: pd.DataFrame, idx: int) -> float: """Calculate normalized volatility""" if 'Close' not in data.columns: return 0.0 prices = data['Close'].iloc[max(0, idx-50):idx+1] if len(prices) < 10: return 0.0 # Calculate multiple volatility measures returns = prices.pct_change().dropna() # Bollinger Band width (normalized) sma = prices.rolling(20).mean() std = prices.rolling(20).std() bb_width = 2 * std / sma bb_volatility = bb_width.iloc[-1] if not bb_width.empty else 0 # ATR if available if 'High' in data.columns and 'Low' in data.columns: high = data['High'].iloc[max(0, idx-20):idx+1] low = data['Low'].iloc[max(0, idx-20):idx+1] close = data['Close'].iloc[max(0, idx-20):idx+1] tr = np.maximum(high - low, np.maximum(abs(high - close.shift(1)), abs(low - close.shift(1)))) atr = tr.rolling(14).mean() atr_volatility = atr.iloc[-1] / prices.iloc[-1] if not atr.empty else 0 else: atr_volatility = 0 # Return volatility ret_volatility = returns.std() * np.sqrt(252) # Annualized # Combine measures combined_volatility = (bb_volatility * 0.4 + atr_volatility * 0.4 + ret_volatility * 0.2) return combined_volatility def _calculate_momentum(self, data: pd.DataFrame, idx: int) -> float: """Calculate momentum indicators""" if 'Close' not in data.columns: return 0.0 prices = data['Close'].iloc[max(0, idx-50):idx+1] if len(prices) < 20: return 0.0 # RSI delta = prices.diff() gain = (delta.where(delta > 0, 0)).rolling(14).mean() loss = (-delta.where(delta < 0, 0)).rolling(14).mean() rs = gain / loss rsi = 100 - (100 / (1 + rs)) rsi_value = rsi.iloc[-1] if not rsi.empty else 50 # MACD momentum ema12 = prices.ewm(span=12).mean() ema26 = prices.ewm(span=26).mean() macd = ema12 - ema26 macd_signal = macd.ewm(span=9).mean() macd_momentum = (macd - macd_signal).iloc[-1] if not macd.empty else 0 # Normalize RSI to momentum score (-1 to 1) rsi_momentum = (rsi_value - 50) / 50 # Combine momentum indicators combined_momentum = (rsi_momentum * 0.6 + np.sign(macd_momentum) * 0.4) return combined_momentum def _calculate_volume_trend(self, data: pd.DataFrame, idx: int) -> float: """Calculate volume trend if volume data is available""" if 'Volume' not in data.columns: return 0.0 volume = data['Volume'].iloc[max(0, idx-50):idx+1] if len(volume) < 20: return 0.0 # Volume trend volume_sma = volume.rolling(20).mean() volume_trend = (volume.iloc[-1] - volume_sma.iloc[-1]) / volume_sma.iloc[-1] return volume_trend def _classify_regime(self, trend_strength: float, volatility: float, momentum: float, volume_trend: float) -> MarketRegime: """ Classify market regime based on calculated indicators """ # Volatility thresholds HIGH_VOL_THRESHOLD = 0.05 LOW_VOL_THRESHOLD = 0.015 # Trend strength thresholds STRONG_TREND_THRESHOLD = 25 MODERATE_TREND_THRESHOLD = 20 # Momentum thresholds BULL_MOMENTUM_THRESHOLD = 0.3 BEAR_MOMENTUM_THRESHOLD = -0.3 # High volatility regime if volatility > HIGH_VOL_THRESHOLD: return MarketRegime.HIGH_VOLATILITY # Low volatility regime if volatility < LOW_VOL_THRESHOLD: return MarketRegime.LOW_VOLATILITY # Strong trending regimes if trend_strength > STRONG_TREND_THRESHOLD: if momentum > BULL_MOMENTUM_THRESHOLD: return MarketRegime.STRONG_BULL elif momentum < BEAR_MOMENTUM_THRESHOLD: return MarketRegime.STRONG_BEAR # Moderate trending regimes if trend_strength > MODERATE_TREND_THRESHOLD: if momentum > 0.1: return MarketRegime.BULL_TREND elif momentum < -0.1: return MarketRegime.BEAR_TREND # Default to ranging market return MarketRegime.RANGING def get_regime_statistics(self) -> Dict: """Get statistics about regime detection performance""" if not self.regime_history: return {} df = pd.DataFrame(self.regime_history) stats = { 'total_observations': len(df), 'regime_distribution': df['regime'].value_counts().to_dict(), 'avg_trend_strength': df['trend_strength'].mean(), 'avg_volatility': df['volatility'].mean(), 'avg_momentum': df['momentum'].mean(), 'regime_transitions': self._calculate_regime_transitions(df) } return stats def _calculate_regime_transitions(self, df: pd.DataFrame) -> Dict: """Calculate regime transition frequencies""" transitions = {} regimes = df['regime'].values for i in range(1, len(regimes)): from_regime = regimes[i-1] to_regime = regimes[i] key = f"{from_regime.value}_to_{to_regime.value}" transitions[key] = transitions.get(key, 0) + 1 return transitions def get_optimal_parameters_for_regime(self, regime: MarketRegime) -> Dict: """Get optimal trading parameters for a specific regime""" return self.parameters.get_parameters(regime) def create_sample_regime_analysis(): """Create a sample analysis showing regime detection in action""" print("🧠 MARKET REGIME DETECTION SYSTEM") print("=" * 50) # Create sample price data np.random.seed(42) n_points = 500 # Generate realistic price data with different regimes base_price = 2000 prices = [base_price] for i in range(1, n_points): # Different volatility regimes if i < 100: # Low volatility ranging volatility = 0.005 trend = 0.0001 elif i < 200: # High volatility volatility = 0.02 trend = 0.0005 elif i < 350: # Strong bull trend volatility = 0.015 trend = 0.002 else: # Bear trend volatility = 0.012 trend = -0.0015 # Add momentum component momentum = 0.1 * (prices[-1] - prices[-2]) / prices[-2] if len(prices) > 1 else 0 # Generate price movement price_change = trend + np.random.normal(0, volatility) + momentum new_price = prices[-1] * (1 + price_change) prices.append(max(1800, min(2200, new_price))) # Create DataFrame data = pd.DataFrame({ 'Close': prices, 'High': [p * (1 + np.random.uniform(0, 0.005)) for p in prices], 'Low': [p * (1 - np.random.uniform(0, 0.005)) for p in prices], 'Volume': np.random.randint(1000, 10000, n_points) }) # Initialize regime detector detector = MarketRegimeDetector() # Analyze regimes regimes = [] regime_params = [] print("\nšŸ” Analyzing market regimes...") for i in range(50, len(data)): # Start after minimum lookback regime, params = detector.detect_regime(data, i) regimes.append(regime) regime_params.append(params) if i % 100 == 0: print(f"Processed {i}/{len(data)} data points...") # Show regime distribution regime_counts = pd.Series([r.value for r in regimes]).value_counts() print("\nšŸ“Š Regime Distribution:") for regime, count in regime_counts.items(): pct = count / len(regimes) * 100 print(f" {regime}: {count} ({pct:.1f}%)") # Show example parameters for each regime print("\nšŸŽÆ Regime-Specific Parameters:") unique_regimes = set(regimes) for regime in unique_regimes: params = detector.get_optimal_parameters_for_regime(regime) print(f"\n{regime.value.upper()}:") print(f" Profit Targets: {[f'{t*100:.1f}%' for t in params['profit_targets']]}") print(f" Trailing Stop: {params['trailing_stop_pct']*100:.1f}%") print(f" Position Size Multiplier: {params['position_size_multiplier']:.1f}x") print(f" Max Holding Time: {params['max_holding_time']} hours") print(f" Breakeven Trigger: {params['breakeven_trigger']*100:.1f}%") print("\nāœ… Market regime detection system ready!") print("This will significantly improve trading performance by adapting to market conditions.") if __name__ == "__main__": create_sample_regime_analysis()