Delete src

src/__init__.py

@@ -1,7 +0,0 @@
-"""
-Professional Quantitative Finance Analysis Platform
-Advanced spectral analysis, Bayesian inference, and ML-based momentum prediction
-"""
-
-__version__ = "2.0.0"
-__author__ = "Quant Analysis Team"

src/bayesian_engine.py

@@ -1,293 +0,0 @@
-"""
-Bayesian inference engine for probabilistic market analysis
-"""
-import numpy as np
-import pandas as pd
-import pymc as pm
-import arviz as az
-from typing import Dict, Tuple, Optional
-from src.config import config
-
-class BayesianAnalyzer:
-    """
-    Bayesian inference for momentum prediction and parameter optimization
-    Uses PyMC for probabilistic modeling
-    """
-    
-    def __init__(self):
-        self.model = None
-        self.trace = None
-        self.posterior_predictive = None
-        
-    def build_momentum_model(
-        self, 
-        features: np.ndarray, 
-        target: np.ndarray,
-        prior_means: Optional[Dict] = None
-    ) -> Tuple[pm.Model, az.InferenceData]:
-        """
-        Build Bayesian linear regression model for momentum prediction
-        
-        Args:
-            features: Feature matrix (n_samples, n_features)
-            target: Target momentum values
-            prior_means: Optional prior means for coefficients
-            
-        Returns:
-            Tuple of (model, trace)
-        """
-        n_features = features.shape[1]
-        
-        with pm.Model() as self.model:
-            # Priors for regression coefficients
-            if prior_means is not None:
-                alpha = pm.Normal('alpha', mu=prior_means.get('alpha', 0), sigma=10)
-                beta = pm.Normal('beta', mu=prior_means.get('beta', np.zeros(n_features)), 
-                               sigma=10, shape=n_features)
-            else:
-                alpha = pm.Normal('alpha', mu=0, sigma=10)
-                beta = pm.Normal('beta', mu=0, sigma=10, shape=n_features)
-            
-            # Prior for noise
-            sigma = pm.HalfNormal('sigma', sigma=1)
-            
-            # Expected value (linear model)
-            mu = alpha + pm.math.dot(features, beta)
-            
-            # Likelihood
-            y_obs = pm.Normal('y_obs', mu=mu, sigma=sigma, observed=target)
-            
-            # Sampling
-            self.trace = pm.sample(
-                draws=config.BAYESIAN_DRAWS,
-                tune=config.BAYESIAN_TUNE,
-                chains=config.BAYESIAN_CHAINS,
-                return_inferencedata=True,
-                progressbar=True
-            )
-            
-            # Posterior predictive sampling
-            pm.sample_posterior_predictive(
-                self.trace, 
-                extend_inferencedata=True,
-                progressbar=True
-            )
-        
-        return self.model, self.trace
-    
-    def predict(self, features: np.ndarray) -> Dict:
-        """
-        Make predictions using trained Bayesian model
-        
-        Args:
-            features: Feature matrix for prediction
-            
-        Returns:
-            Dictionary with predictions and uncertainty estimates
-        """
-        if self.model is None or self.trace is None:
-            raise ValueError("Model not trained yet. Call build_momentum_model first.")
-        
-        with self.model:
-            # Get posterior samples
-            alpha_samples = self.trace.posterior['alpha'].values.flatten()
-            beta_samples = self.trace.posterior['beta'].values.reshape(-1, features.shape[1])
-            
-            # Calculate predictions for each posterior sample
-            predictions = []
-            for i in range(len(alpha_samples)):
-                pred = alpha_samples[i] + features @ beta_samples[i]
-                predictions.append(pred)
-            
-            predictions = np.array(predictions)
-            
-            # Calculate statistics
-            mean_pred = np.mean(predictions, axis=0)
-            std_pred = np.std(predictions, axis=0)
-            
-            # Credible intervals (95%)
-            lower_ci = np.percentile(predictions, 2.5, axis=0)
-            upper_ci = np.percentile(predictions, 97.5, axis=0)
-            
-        return {
-            'mean': mean_pred,
-            'std': std_pred,
-            'lower_95': lower_ci,
-            'upper_95': upper_ci,
-            'samples': predictions
-        }
-    
-    def update_priors(self, new_data_features: np.ndarray, new_data_target: np.ndarray):
-        """
-        Update model with new data (online learning)
-        Uses previous posterior as new prior
-        
-        Args:
-            new_data_features: New feature data
-            new_data_target: New target data
-        """
-        if self.trace is None:
-            # First time - no prior information
-            return self.build_momentum_model(new_data_features, new_data_target)
-        
-        # Extract posterior means as new priors
-        alpha_mean = float(self.trace.posterior['alpha'].mean())
-        beta_mean = self.trace.posterior['beta'].mean(dim=['chain', 'draw']).values
-        
-        prior_means = {
-            'alpha': alpha_mean,
-            'beta': beta_mean
-        }
-        
-        # Build new model with updated priors
-        return self.build_momentum_model(new_data_features, new_data_target, prior_means)
-    
-    def estimate_regime_probabilities(
-        self, 
-        volatility: float, 
-        adx: float,
-        returns: np.ndarray
-    ) -> Dict[str, float]:
-        """
-        Estimate probabilities of different market regimes using Bayesian approach
-        
-        Args:
-            volatility: Current volatility measure
-            adx: Current ADX value
-            returns: Recent returns series
-            
-        Returns:
-            Dictionary of regime probabilities
-        """
-        with pm.Model() as regime_model:
-            # Define regime categories
-            # 0: Range-bound, 1: Trending, 2: High volatility
-            
-            # Prior probabilities (equal initially)
-            p = pm.Dirichlet('p', a=np.ones(3))
-            
-            # Regime indicators
-            regime = pm.Categorical('regime', p=p, shape=len(returns))
-            
-            # Likelihood parameters for each regime
-            # Range-bound: low volatility, low ADX
-            mu_range = pm.Normal('mu_range', mu=0, sigma=0.5)
-            sigma_range = pm.HalfNormal('sigma_range', sigma=0.3)
-            
-            # Trending: moderate volatility, high ADX
-            mu_trend = pm.Normal('mu_trend', mu=0, sigma=1.0)
-            sigma_trend = pm.HalfNormal('sigma_trend', sigma=0.5)
-            
-            # High vol: high volatility, variable ADX
-            mu_highvol = pm.Normal('mu_highvol', mu=0, sigma=2.0)
-            sigma_highvol = pm.HalfNormal('sigma_highvol', sigma=1.0)
-            
-            # Mixture likelihood
-            mus = pm.math.stack([mu_range, mu_trend, mu_highvol])
-            sigmas = pm.math.stack([sigma_range, sigma_trend, sigma_highvol])
-            
-            # Observed returns
-            y = pm.Normal('y', mu=mus[regime], sigma=sigmas[regime], observed=returns)
-            
-            # Sample
-            trace = pm.sample(
-                draws=2000,
-                tune=1000,
-                chains=2,
-                return_inferencedata=True,
-                progressbar=False
-            )
-        
-        # Extract regime probabilities
-        regime_probs = trace.posterior['p'].mean(dim=['chain', 'draw']).values
-        
-        return {
-            'range_bound': float(regime_probs[0]),
-            'trending': float(regime_probs[1]),
-            'high_volatility': float(regime_probs[2])
-        }
-    
-    def optimize_parameters_bayesian(
-        self,
-        historical_signals: pd.DataFrame,
-        forward_returns: pd.Series
-    ) -> Dict:
-        """
-        Optimize signal parameters using Bayesian optimization
-        
-        Args:
-            historical_signals: DataFrame with signal features
-            forward_returns: Actual forward returns
-            
-        Returns:
-            Optimized parameter distributions
-        """
-        with pm.Model() as param_model:
-            # Parameters to optimize
-            momentum_threshold = pm.Normal('momentum_threshold', mu=-0.3, sigma=0.2)
-            price_threshold = pm.Normal('price_threshold', mu=-0.05, sigma=0.05)
-            cutoff_freq = pm.Beta('cutoff_freq', alpha=2, beta=5)
-            
-            # Generate signals based on parameters
-            # (simplified for demonstration)
-            signal_strength = (
-                historical_signals['momentum'] - momentum_threshold
-            ) * (
-                historical_signals['price_change'] - price_threshold
-            )
-            
-            # Likelihood: forward returns should be positive when signal is strong
-            pm.Normal(
-                'forward_returns',
-                mu=signal_strength * 0.05,  # Expected 5% return on strong signal
-                sigma=0.1,
-                observed=forward_returns
-            )
-            
-            # Sample
-            trace = pm.sample(
-                draws=3000,
-                tune=1500,
-                chains=4,
-                return_inferencedata=True,
-                progressbar=True
-            )
-        
-        # Extract optimal parameters
-        optimal_params = {
-            'momentum_threshold': {
-                'mean': float(trace.posterior['momentum_threshold'].mean()),
-                'std': float(trace.posterior['momentum_threshold'].std()),
-                'hdi_95': tuple(az.hdi(trace, var_names=['momentum_threshold'], hdi_prob=0.95)['momentum_threshold'].values)
-            },
-            'price_threshold': {
-                'mean': float(trace.posterior['price_threshold'].mean()),
-                'std': float(trace.posterior['price_threshold'].std()),
-                'hdi_95': tuple(az.hdi(trace, var_names=['price_threshold'], hdi_prob=0.95)['price_threshold'].values)
-            },
-            'cutoff_freq': {
-                'mean': float(trace.posterior['cutoff_freq'].mean()),
-                'std': float(trace.posterior['cutoff_freq'].std()),
-                'hdi_95': tuple(az.hdi(trace, var_names=['cutoff_freq'], hdi_prob=0.95)['cutoff_freq'].values)
-            }
-        }
-        
-        return optimal_params
-    
-    def get_diagnostics(self) -> Dict:
-        """
-        Get MCMC diagnostics
-        
-        Returns:
-            Dictionary with diagnostic metrics
-        """
-        if self.trace is None:
-            return {}
-        
-        diagnostics = {
-            'r_hat': az.rhat(self.trace).to_dict(),
-            'ess': az.ess(self.trace).to_dict(),
-            'divergences': self.trace.sample_stats.diverging.sum().item()
-        }
-        
-        return diagnostics

src/config.py

@@ -1,101 +0,0 @@
-"""
-Configuration management for the quantitative finance platform
-"""
-import os
-from dataclasses import dataclass
-from typing import Dict, List, Tuple
-
-@dataclass
-class FrequencyBand:
-    """Frequency band configuration"""
-    name: str
-    min_period: float  # days
-    max_period: float  # days
-    cutoff_range: Tuple[float, float]
-    filter_order: int
-
-@dataclass
-class AnalysisConfig:
-    """Main analysis configuration"""
-    
-    # Frequency bands (Low, Mid, High)
-    FREQUENCY_BANDS: Dict[str, FrequencyBand] = None
-    
-    # Bayesian configuration
-    BAYESIAN_DRAWS: int = 5000
-    BAYESIAN_TUNE: int = 2000
-    BAYESIAN_CHAINS: int = 4
-    
-    # Monte Carlo configuration
-    MC_SIMULATIONS: int = 10000
-    MC_TIME_HORIZON: int = 30  # days
-    
-    # Self-supervised learning
-    ROLLING_WINDOW_SIZE: int = 252  # 1 year
-    FORWARD_TEST_SIZE: int = 21  # 1 month
-    OPTIMIZATION_ITERATIONS: int = 50
-    
-    # Pattern recognition
-    PATTERN_WINDOW_MIN: int = 5
-    PATTERN_WINDOW_MAX: int = 60
-    PATTERN_SIMILARITY_THRESHOLD: float = 0.75
-    
-    # Machine Learning
-    ML_VALIDATION_SPLITS: int = 5
-    ML_TEST_SIZE: float = 0.2
-    ML_RANDOM_STATE: int = 42
-    
-    # Visualization
-    PLOT_DPI: int = 300
-    PLOT_WIDTH: int = 1400
-    PLOT_HEIGHT: int = 800
-    
-    # PDF Report
-    PDF_PAGE_SIZE: str = "A4"
-    PDF_FONT_SIZE: int = 10
-    PDF_TITLE_SIZE: int = 16
-    
-    def __post_init__(self):
-        if self.FREQUENCY_BANDS is None:
-            self.FREQUENCY_BANDS = {
-                'low': FrequencyBand(
-                    name='Low Frequency (Long-term)',
-                    min_period=20.0,
-                    max_period=252.0,
-                    cutoff_range=(0.02, 0.05),
-                    filter_order=6
-                ),
-                'mid': FrequencyBand(
-                    name='Mid Frequency (Medium-term)',
-                    min_period=5.0,
-                    max_period=20.0,
-                    cutoff_range=(0.05, 0.15),
-                    filter_order=4
-                ),
-                'high': FrequencyBand(
-                    name='High Frequency (Short-term)',
-                    min_period=1.0,
-                    max_period=5.0,
-                    cutoff_range=(0.15, 0.4),
-                    filter_order=3
-                )
-            }
-
-# Global configuration instance
-config = AnalysisConfig()
-
-# Time intervals for different analyses
-TIMEFRAMES = {
-    '1d': {'name': '1 Day', 'interval': '1d', 'period': '2y'},
-    '1h': {'name': '1 Hour', 'interval': '1h', 'period': '60d'},
-    '15m': {'name': '15 Minutes', 'interval': '15m', 'period': '7d'},
-    '5m': {'name': '5 Minutes', 'interval': '5m', 'period': '5d'},
-}
-
-# Market regime thresholds
-REGIME_THRESHOLDS = {
-    'trending': 25.0,  # ADX threshold
-    'range_bound': 20.0,
-    'high_volatility': 0.30,
-    'low_volatility': 0.15
-}

src/data_fetcher.py

@@ -1,192 +0,0 @@
-"""
-Data fetching and preprocessing module
-"""
-import yfinance as yf
-import pandas as pd
-import numpy as np
-from typing import Tuple, Optional
-from datetime import datetime, timedelta
-import warnings
-warnings.filterwarnings('ignore')
-
-class DataFetcher:
-    """Fetches and preprocesses financial market data"""
-    
-    def __init__(self):
-        self.data = None
-        self.symbol = None
-        self.interval = None
-        
-    def fetch_data(self, symbol: str, interval: str = '1d', period: str = '2y') -> Tuple[bool, str]:
-        """
-        Fetch market data from Yahoo Finance
-        
-        Args:
-            symbol: Stock ticker symbol
-            interval: Data interval (1d, 1h, 15m, 5m)
-            period: Historical period to fetch
-            
-        Returns:
-            Tuple of (success: bool, message: str)
-        """
-        try:
-            symbol = symbol.strip().upper()
-            self.symbol = symbol
-            self.interval = interval
-            
-            ticker = yf.Ticker(symbol)
-            self.data = ticker.history(period=period, interval=interval)
-            
-            if len(self.data) < 60:
-                return False, f"Insufficient data: Only {len(self.data)} records found for {symbol}"
-            
-            # Add technical indicators
-            self._add_technical_indicators()
-            
-            return True, f"{symbol} data successfully fetched: {len(self.data)} records ({interval} interval)"
-            
-        except Exception as e:
-            return False, f"Data fetch error: {str(e)}"
-    
-    def _add_technical_indicators(self):
-        """Add common technical indicators to the dataset"""
-        if self.data is None or len(self.data) == 0:
-            return
-        
-        # Returns
-        self.data['Returns'] = self.data['Close'].pct_change()
-        
-        # Log returns
-        self.data['LogReturns'] = np.log(self.data['Close'] / self.data['Close'].shift(1))
-        
-        # Simple Moving Averages
-        for period in [5, 10, 20, 50, 200]:
-            if len(self.data) > period:
-                self.data[f'SMA_{period}'] = self.data['Close'].rolling(window=period).mean()
-        
-        # Exponential Moving Averages
-        for period in [12, 26]:
-            if len(self.data) > period:
-                self.data[f'EMA_{period}'] = self.data['Close'].ewm(span=period, adjust=False).mean()
-        
-        # Bollinger Bands
-        if len(self.data) > 20:
-            sma_20 = self.data['Close'].rolling(window=20).mean()
-            std_20 = self.data['Close'].rolling(window=20).std()
-            self.data['BB_Upper'] = sma_20 + (std_20 * 2)
-            self.data['BB_Lower'] = sma_20 - (std_20 * 2)
-            self.data['BB_Width'] = (self.data['BB_Upper'] - self.data['BB_Lower']) / sma_20
-        
-        # RSI (Relative Strength Index)
-        if len(self.data) > 14:
-            delta = self.data['Close'].diff()
-            gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
-            loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
-            rs = gain / loss
-            self.data['RSI'] = 100 - (100 / (1 + rs))
-        
-        # MACD
-        if len(self.data) > 26:
-            ema_12 = self.data['Close'].ewm(span=12, adjust=False).mean()
-            ema_26 = self.data['Close'].ewm(span=26, adjust=False).mean()
-            self.data['MACD'] = ema_12 - ema_26
-            self.data['MACD_Signal'] = self.data['MACD'].ewm(span=9, adjust=False).mean()
-            self.data['MACD_Hist'] = self.data['MACD'] - self.data['MACD_Signal']
-        
-        # Average True Range (ATR)
-        if len(self.data) > 14:
-            high_low = self.data['High'] - self.data['Low']
-            high_close = np.abs(self.data['High'] - self.data['Close'].shift())
-            low_close = np.abs(self.data['Low'] - self.data['Close'].shift())
-            ranges = pd.concat([high_low, high_close, low_close], axis=1)
-            true_range = ranges.max(axis=1)
-            self.data['ATR'] = true_range.rolling(window=14).mean()
-        
-        # Volume indicators
-        if 'Volume' in self.data.columns:
-            self.data['Volume_SMA'] = self.data['Volume'].rolling(window=20).mean()
-            self.data['Volume_Ratio'] = self.data['Volume'] / self.data['Volume_SMA']
-    
-    def get_clean_prices(self) -> np.ndarray:
-        """Get clean closing prices without NaN values"""
-        return self.data['Close'].fillna(method='ffill').fillna(method='bfill').values
-    
-    def get_returns(self) -> np.ndarray:
-        """Get returns series"""
-        returns = self.data['Returns'].fillna(0).values
-        return returns
-    
-    def get_ohlcv(self) -> pd.DataFrame:
-        """Get OHLCV data"""
-        return self.data[['Open', 'High', 'Low', 'Close', 'Volume']].copy()
-    
-    def calculate_volatility(self, window: int = 20) -> pd.Series:
-        """Calculate rolling volatility (annualized)"""
-        returns = self.data['Close'].pct_change()
-        
-        # Determine scaling factor based on interval
-        if self.interval == '1d':
-            scale = np.sqrt(252)
-        elif self.interval == '1h':
-            scale = np.sqrt(252 * 6.5)  # 6.5 trading hours
-        elif self.interval == '15m':
-            scale = np.sqrt(252 * 6.5 * 4)  # 4 periods per hour
-        elif self.interval == '5m':
-            scale = np.sqrt(252 * 6.5 * 12)  # 12 periods per hour
-        else:
-            scale = np.sqrt(252)
-        
-        volatility = returns.rolling(window=window).std() * scale
-        
-        # Fill initial NaN values
-        first_valid = volatility.first_valid_index()
-        if first_valid is not None:
-            first_vol = volatility.loc[first_valid]
-            volatility = volatility.fillna(first_vol)
-        else:
-            volatility = pd.Series(0.2, index=self.data.index)
-        
-        return volatility
-    
-    def detect_market_regime(self, lookback: int = 50) -> str:
-        """
-        Detect market regime using ADX (Average Directional Index)
-        
-        Returns:
-            Market regime: 'Trending', 'Range-Bound', or 'Transitional'
-        """
-        high = self.data['High']
-        low = self.data['Low']
-        close = self.data['Close']
-        
-        # True Range
-        tr1 = high - low
-        tr2 = abs(high - close.shift())
-        tr3 = abs(low - close.shift())
-        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
-        
-        # Directional Movement
-        up_move = high - high.shift()
-        down_move = low.shift() - low
-        
-        plus_dm = np.where((up_move > down_move) & (up_move > 0), up_move, 0)
-        minus_dm = np.where((down_move > up_move) & (down_move > 0), down_move, 0)
-        
-        # ATR and Directional Indicators
-        atr = tr.rolling(window=lookback).mean()
-        plus_di = pd.Series(plus_dm).rolling(window=lookback).mean() / atr * 100
-        minus_di = pd.Series(minus_dm).rolling(window=lookback).mean() / atr * 100
-        
-        # ADX
-        dx = abs(plus_di - minus_di) / (plus_di + minus_di) * 100
-        adx = dx.rolling(window=lookback).mean()
-        
-        adx = adx.fillna(20)
-        current_adx = adx.iloc[-1]
-        
-        if current_adx > 25:
-            return "Trending"
-        elif current_adx < 20:
-            return "Range-Bound"
-        else:
-            return "Transitional"

src/ml_models.py

@@ -1,240 +0,0 @@
-"""
-Machine Learning models with self-supervised learning
-"""
-import numpy as np
-import pandas as pd
-from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor
-from sklearn.model_selection import TimeSeriesSplit, GridSearchCV, RandomizedSearchCV
-from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
-import xgboost as xgb
-import lightgbm as lgb
-from typing import Dict, Tuple, List
-from src.config import config
-
-class MLMomentumPredictor:
-    """
-    Self-supervised learning for momentum prediction
-    Continuously learns from past predictions
-    """
-    
-    def __init__(self, model_type: str = 'xgboost'):
-        self.model_type = model_type
-        self.model = None
-        self.scaler = StandardScaler()
-        self.feature_importance = None
-        self.validation_history = []
-        self.optimal_params = None
-        
-    def prepare_features(self, data: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]:
-        """
-        Engineer features from market data
-        
-        Returns:
-            Tuple of (features, target)
-        """
-        features_list = []
-        
-        # Price-based features
-        features_list.append(data['Returns'].values.reshape(-1, 1))
-        features_list.append(data['LogReturns'].values.reshape(-1, 1))
-        
-        # Technical indicators
-        for col in data.columns:
-            if col.startswith(('SMA_', 'EMA_', 'RSI', 'MACD', 'ATR', 'BB_')):
-                features_list.append(data[col].values.reshape(-1, 1))
-        
-        # Lag features
-        for lag in [1, 2, 3, 5, 10]:
-            lag_returns = data['Returns'].shift(lag).values.reshape(-1, 1)
-            features_list.append(lag_returns)
-        
-        # Rolling statistics
-        for window in [5, 10, 20]:
-            roll_mean = data['Close'].rolling(window).mean().pct_change().values.reshape(-1, 1)
-            roll_std = data['Close'].rolling(window).std().values.reshape(-1, 1)
-            features_list.append(roll_mean)
-            features_list.append(roll_std)
-        
-        # Combine all features
-        X = np.hstack(features_list)
-        
-        # Target: future returns (5 days ahead)
-        y = data['Close'].pct_change(5).shift(-5).values
-        
-        # Remove NaN rows
-        valid_idx = ~(np.isnan(X).any(axis=1) | np.isnan(y))
-        X = X[valid_idx]
-        y = y[valid_idx]
-        
-        return X, y
-    
-    def self_supervised_training(
-        self, 
-        X: np.ndarray, 
-        y: np.ndarray,
-        optimize_params: bool = True
-    ) -> Dict:
-        """
-        Train model using rolling window walk-forward validation
-        Self-supervised: learns from past predictions
-        
-        Returns:
-            Training metrics
-        """
-        n_splits = max(3, len(X) // config.ROLLING_WINDOW_SIZE)
-        tscv = TimeSeriesSplit(n_splits=n_splits)
-        
-        all_predictions = []
-        all_actuals = []
-        
-        for train_idx, val_idx in tscv.split(X):
-            X_train, X_val = X[train_idx], X[val_idx]
-            y_train, y_val = y[train_idx], y[val_idx]
-            
-            # Scale features
-            X_train_scaled = self.scaler.fit_transform(X_train)
-            X_val_scaled = self.scaler.transform(X_val)
-            
-            # Train model
-            if optimize_params and self.optimal_params is None:
-                self._optimize_hyperparameters(X_train_scaled, y_train)
-            
-            model = self._create_model()
-            model.fit(X_train_scaled, y_train)
-            
-            # Predict
-            y_pred = model.predict(X_val_scaled)
-            
-            # Store results
-            all_predictions.extend(y_pred)
-            all_actuals.extend(y_val)
-            
-            # Calculate validation metrics
-            val_metrics = {
-                'mse': mean_squared_error(y_val, y_pred),
-                'mae': mean_absolute_error(y_val, y_pred),
-                'r2': r2_score(y_val, y_pred)
-            }
-            self.validation_history.append(val_metrics)
-        
-        # Train final model on all data
-        X_scaled = self.scaler.fit_transform(X)
-        self.model = self._create_model()
-        self.model.fit(X_scaled, y)
-        
-        # Feature importance
-        if hasattr(self.model, 'feature_importances_'):
-            self.feature_importance = self.model.feature_importances_
-        
-        # Overall metrics
-        overall_metrics = {
-            'avg_mse': np.mean([v['mse'] for v in self.validation_history]),
-            'avg_mae': np.mean([v['mae'] for v in self.validation_history]),
-            'avg_r2': np.mean([v['r2'] for v in self.validation_history]),
-            'final_mse': mean_squared_error(all_actuals, all_predictions),
-            'final_r2': r2_score(all_actuals, all_predictions)
-        }
-        
-        return overall_metrics
-    
-    def _create_model(self):
-        """Create ML model based on type"""
-        if self.model_type == 'xgboost':
-            params = self.optimal_params if self.optimal_params else {
-                'n_estimators': 200,
-                'max_depth': 5,
-                'learning_rate': 0.05,
-                'subsample': 0.8
-            }
-            return xgb.XGBRegressor(**params, random_state=config.ML_RANDOM_STATE)
-        
-        elif self.model_type == 'lightgbm':
-            params = self.optimal_params if self.optimal_params else {
-                'n_estimators': 200,
-                'max_depth': 5,
-                'learning_rate': 0.05,
-                'subsample': 0.8
-            }
-            return lgb.LGBMRegressor(**params, random_state=config.ML_RANDOM_STATE, verbose=-1)
-        
-        elif self.model_type == 'gradient_boosting':
-            params = self.optimal_params if self.optimal_params else {
-                'n_estimators': 200,
-                'max_depth': 5,
-                'learning_rate': 0.05,
-                'subsample': 0.8
-            }
-            return GradientBoostingRegressor(**params, random_state=config.ML_RANDOM_STATE)
-        
-        else:  # random_forest
-            params = self.optimal_params if self.optimal_params else {
-                'n_estimators': 200,
-                'max_depth': 10
-            }
-            return RandomForestRegressor(**params, random_state=config.ML_RANDOM_STATE)
-    
-    def _optimize_hyperparameters(self, X: np.ndarray, y: np.ndarray):
-        """Optimize hyperparameters using GridSearch"""
-        if self.model_type == 'xgboost':
-            param_grid = {
-                'n_estimators': [100, 200, 500],
-                'max_depth': [3, 5, 7],
-                'learning_rate': [0.01, 0.05, 0.1],
-                'subsample': [0.7, 0.8, 0.9]
-            }
-            base_model = xgb.XGBRegressor(random_state=config.ML_RANDOM_STATE)
-        
-        elif self.model_type == 'lightgbm':
-            param_grid = {
-                'n_estimators': [100, 200, 500],
-                'max_depth': [3, 5, 7],
-                'learning_rate': [0.01, 0.05, 0.1],
-                'subsample': [0.7, 0.8, 0.9]
-            }
-            base_model = lgb.LGBMRegressor(random_state=config.ML_RANDOM_STATE, verbose=-1)
-        
-        else:
-            param_grid = {
-                'n_estimators': [100, 200, 500],
-                'max_depth': [3, 5, 7, 10],
-                'learning_rate': [0.01, 0.05, 0.1]
-            }
-            base_model = GradientBoostingRegressor(random_state=config.ML_RANDOM_STATE)
-        
-        # Use RandomizedSearch for efficiency
-        search = RandomizedSearchCV(
-            base_model,
-            param_grid,
-            n_iter=20,
-            cv=3,
-            scoring='neg_mean_squared_error',
-            random_state=config.ML_RANDOM_STATE,
-            n_jobs=-1
-        )
-        
-        search.fit(X, y)
-        self.optimal_params = search.best_params_
-    
-    def predict(self, X: np.ndarray) -> np.ndarray:
-        """Make predictions"""
-        if self.model is None:
-            raise ValueError("Model not trained yet")
-        
-        X_scaled = self.scaler.transform(X)
-        return self.model.predict(X_scaled)
-    
-    def get_feature_importance(self, feature_names: List[str] = None) -> pd.DataFrame:
-        """Get feature importance rankings"""
-        if self.feature_importance is None:
-            return pd.DataFrame()
-        
-        if feature_names is None:
-            feature_names = [f'feature_{i}' for i in range(len(self.feature_importance))]
-        
-        importance_df = pd.DataFrame({
-            'feature': feature_names,
-            'importance': self.feature_importance
-        }).sort_values('importance', ascending=False)
-        
-        return importance_df

src/monte_carlo.py

@@ -1,339 +0,0 @@
-"""
-Monte Carlo simulation engine for probabilistic forecasting
-"""
-import numpy as np
-import pandas as pd
-from typing import Dict, List, Tuple
-from scipy import stats
-from src.config import config
-
-class MonteCarloEngine:
-    """
-    Advanced Monte Carlo simulation with multiple stochastic models
-    Supports GBM, Jump Diffusion, and GARCH-based simulations
-    """
-    
-    def __init__(self):
-        self.simulations = None
-        self.statistics = None
-        
-    def geometric_brownian_motion(
-        self,
-        S0: float,
-        mu: float,
-        sigma: float,
-        T: int,
-        n_sims: int = None
-    ) -> np.ndarray:
-        """
-        Geometric Brownian Motion simulation
-        
-        Args:
-            S0: Initial price
-            mu: Drift (expected return)
-            sigma: Volatility
-            T: Time horizon (days)
-            n_sims: Number of simulations
-            
-        Returns:
-            Array of simulated price paths (n_sims, T)
-        """
-        if n_sims is None:
-            n_sims = config.MC_SIMULATIONS
-        
-        dt = 1  # Daily steps
-        paths = np.zeros((n_sims, T))
-        paths[:, 0] = S0
-        
-        for t in range(1, T):
-            Z = np.random.standard_normal(n_sims)
-            paths[:, t] = paths[:, t-1] * np.exp(
-                (mu - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z
-            )
-        
-        return paths
-    
-    def jump_diffusion(
-        self,
-        S0: float,
-        mu: float,
-        sigma: float,
-        lambda_jump: float,
-        jump_mean: float,
-        jump_std: float,
-        T: int,
-        n_sims: int = None
-    ) -> np.ndarray:
-        """
-        Merton's Jump Diffusion model
-        
-        Args:
-            S0: Initial price
-            mu: Drift
-            sigma: Diffusion volatility
-            lambda_jump: Jump intensity (jumps per day)
-            jump_mean: Mean jump size
-            jump_std: Jump size standard deviation
-            T: Time horizon
-            n_sims: Number of simulations
-            
-        Returns:
-            Array of simulated price paths
-        """
-        if n_sims is None:
-            n_sims = config.MC_SIMULATIONS
-        
-        dt = 1
-        paths = np.zeros((n_sims, T))
-        paths[:, 0] = S0
-        
-        for t in range(1, T):
-            # Diffusion component
-            Z = np.random.standard_normal(n_sims)
-            diffusion = (mu - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z
-            
-            # Jump component
-            N = np.random.poisson(lambda_jump * dt, n_sims)  # Number of jumps
-            jump_sizes = np.random.normal(jump_mean, jump_std, n_sims) * N
-            
-            # Combined evolution
-            paths[:, t] = paths[:, t-1] * np.exp(diffusion + jump_sizes)
-        
-        return paths
-    
-    def garch_simulation(
-        self,
-        S0: float,
-        returns: np.ndarray,
-        T: int,
-        n_sims: int = None
-    ) -> np.ndarray:
-        """
-        GARCH(1,1) based simulation
-        
-        Args:
-            S0: Initial price
-            returns: Historical returns for parameter estimation
-            T: Time horizon
-            n_sims: Number of simulations
-            
-        Returns:
-            Array of simulated price paths
-        """
-        if n_sims is None:
-            n_sims = config.MC_SIMULATIONS
-        
-        # Estimate GARCH parameters
-        omega, alpha, beta = self._estimate_garch_params(returns)
-        
-        paths = np.zeros((n_sims, T))
-        paths[:, 0] = S0
-        
-        # Initialize volatility
-        sigma_sq = np.var(returns)
-        
-        for sim in range(n_sims):
-            prices = [S0]
-            var = sigma_sq
-            
-            for t in range(1, T):
-                # Generate return with time-varying volatility
-                epsilon = np.random.standard_normal()
-                ret = np.sqrt(var) * epsilon
-                
-                # Update price
-                new_price = prices[-1] * (1 + ret)
-                prices.append(new_price)
-                
-                # Update variance (GARCH dynamics)
-                var = omega + alpha * (ret**2) + beta * var
-            
-            paths[sim, :] = prices
-        
-        return paths
-    
-    def _estimate_garch_params(self, returns: np.ndarray) -> Tuple[float, float, float]:
-        """
-        Simple GARCH(1,1) parameter estimation using method of moments
-        
-        Returns:
-            Tuple of (omega, alpha, beta)
-        """
-        # Simple estimation (could be improved with MLE)
-        variance = np.var(returns)
-        
-        # Typical values for GARCH(1,1)
-        alpha = 0.1
-        beta = 0.85
-        omega = variance * (1 - alpha - beta)
-        
-        return omega, alpha, beta
-    
-    def heston_model(
-        self,
-        S0: float,
-        v0: float,
-        kappa: float,
-        theta: float,
-        sigma_v: float,
-        rho: float,
-        mu: float,
-        T: int,
-        n_sims: int = None
-    ) -> Tuple[np.ndarray, np.ndarray]:
-        """
-        Heston stochastic volatility model
-        
-        Args:
-            S0: Initial price
-            v0: Initial variance
-            kappa: Mean reversion speed
-            theta: Long-term variance
-            sigma_v: Volatility of volatility
-            rho: Correlation between price and volatility
-            mu: Drift
-            T: Time horizon
-            n_sims: Number of simulations
-            
-        Returns:
-            Tuple of (price_paths, variance_paths)
-        """
-        if n_sims is None:
-            n_sims = config.MC_SIMULATIONS
-        
-        dt = 1
-        price_paths = np.zeros((n_sims, T))
-        var_paths = np.zeros((n_sims, T))
-        
-        price_paths[:, 0] = S0
-        var_paths[:, 0] = v0
-        
-        for t in range(1, T):
-            # Correlated random variables
-            Z1 = np.random.standard_normal(n_sims)
-            Z2 = rho * Z1 + np.sqrt(1 - rho**2) * np.random.standard_normal(n_sims)
-            
-            # Variance process (with truncation to ensure positivity)
-            var_paths[:, t] = np.maximum(
-                var_paths[:, t-1] + kappa * (theta - var_paths[:, t-1]) * dt + 
-                sigma_v * np.sqrt(var_paths[:, t-1] * dt) * Z2,
-                1e-10
-            )
-            
-            # Price process
-            price_paths[:, t] = price_paths[:, t-1] * np.exp(
-                (mu - 0.5 * var_paths[:, t-1]) * dt + 
-                np.sqrt(var_paths[:, t-1] * dt) * Z1
-            )
-        
-        return price_paths, var_paths
-    
-    def simulate_all_models(
-        self,
-        S0: float,
-        returns: np.ndarray,
-        T: int = None,
-        n_sims: int = None
-    ) -> Dict[str, np.ndarray]:
-        """
-        Run all Monte Carlo models and return results
-        
-        Args:
-            S0: Current price
-            returns: Historical returns
-            T: Forecast horizon
-            n_sims: Number of simulations
-            
-        Returns:
-            Dictionary with results from each model
-        """
-        if T is None:
-            T = config.MC_TIME_HORIZON
-        if n_sims is None:
-            n_sims = config.MC_SIMULATIONS
-        
-        # Estimate parameters from historical data
-        mu = np.mean(returns)
-        sigma = np.std(returns)
-        
-        # Estimate jump parameters
-        # Identify potential jumps (returns > 3 std)
-        jump_threshold = 3 * sigma
-        jumps = returns[np.abs(returns) > jump_threshold]
-        lambda_jump = len(jumps) / len(returns)  # Jumps per day
-        jump_mean = np.mean(jumps) if len(jumps) > 0 else 0
-        jump_std = np.std(jumps) if len(jumps) > 1 else sigma
-        
-        # Run simulations
-        results = {
-            'gbm': self.geometric_brownian_motion(S0, mu, sigma, T, n_sims),
-            'jump_diffusion': self.jump_diffusion(
-                S0, mu, sigma, lambda_jump, jump_mean, jump_std, T, n_sims
-            ),
-            'garch': self.garch_simulation(S0, returns, T, n_sims)
-        }
-        
-        # Heston model (with estimated parameters)
-        v0 = sigma**2
-        kappa = 2.0  # Mean reversion speed
-        theta = sigma**2  # Long-term variance
-        sigma_v = 0.3  # Vol of vol
-        rho = -0.7  # Typical negative correlation
-        
-        price_paths_heston, var_paths_heston = self.heston_model(
-            S0, v0, kappa, theta, sigma_v, rho, mu, T, n_sims
-        )
-        results['heston'] = price_paths_heston
-        results['heston_variance'] = var_paths_heston
-        
-        self.simulations = results
-        return results
-    
-    def calculate_statistics(self, model_name: str = 'gbm') -> Dict:
-        """
-        Calculate statistics from simulations
-        
-        Args:
-            model_name: Which model to analyze
-            
-        Returns:
-            Dictionary of statistics
-        """
-        if self.simulations is None or model_name not in self.simulations:
-            raise ValueError(f"Model '{model_name}' not simulated yet")
-        
-        paths = self.simulations[model_name]
-        final_prices = paths[:, -1]
-        
-        statistics = {
-            'mean_final_price': float(np.mean(final_prices)),
-            'median_final_price': float(np.median(final_prices)),
-            'std_final_price': float(np.std(final_prices)),
-            'percentile_5': float(np.percentile(final_prices, 5)),
-            'percentile_25': float(np.percentile(final_prices, 25)),
-            'percentile_75': float(np.percentile(final_prices, 75)),
-            'percentile_95': float(np.percentile(final_prices, 95)),
-            'prob_profit': float(np.mean(final_prices > paths[0, 0])),
-            'expected_return': float(np.mean((final_prices - paths[0, 0]) / paths[0, 0])),
-            'var_95': float(np.percentile(final_prices, 5)),  # Value at Risk
-            'cvar_95': float(np.mean(final_prices[final_prices <= np.percentile(final_prices, 5)]))  # CVaR
-        }
-        
-        self.statistics = statistics
-        return statistics
-    
-    def get_probability_distribution(self, model_name: str = 'gbm', bins: int = 50) -> Tuple[np.ndarray, np.ndarray]:
-        """
-        Get probability distribution of final prices
-        
-        Returns:
-            Tuple of (bin_centers, probabilities)
-        """
-        if self.simulations is None or model_name not in self.simulations:
-            raise ValueError(f"Model '{model_name}' not simulated yet")
-        
-        final_prices = self.simulations[model_name][:, -1]
-        counts, bin_edges = np.histogram(final_prices, bins=bins, density=True)
-        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
-        
-        return bin_centers, counts

src/pattern_recognition.py

@@ -1,395 +0,0 @@
-"""
-Pattern recognition module for technical analysis
-Includes candlestick patterns, chart patterns, and ML-based clustering
-"""
-import numpy as np
-import pandas as pd
-from typing import List, Dict, Tuple
-from scipy.spatial.distance import euclidean
-from scipy.signal import find_peaks, argrelextrema
-from tslearn.clustering import TimeSeriesKMeans
-from tslearn.metrics import dtw
-from src.config import config
-
-class PatternRecognizer:
-    """
-    Advanced pattern recognition combining technical patterns and ML
-    """
-    
-    def __init__(self):
-        self.patterns_found = []
-        self.clusters = None
-        self.cluster_model = None
-        
-    def detect_candlestick_patterns(self, ohlc: pd.DataFrame) -> List[Dict]:
-        """
-        Detect common candlestick patterns
-        
-        Args:
-            ohlc: DataFrame with Open, High, Low, Close columns
-            
-        Returns:
-            List of detected patterns
-        """
-        patterns = []
-        
-        for i in range(2, len(ohlc)):
-            pattern_info = {
-                'index': i,
-                'date': ohlc.index[i],
-                'pattern': None,
-                'signal': None
-            }
-            
-            # Get candles
-            c0 = ohlc.iloc[i]    # Current
-            c1 = ohlc.iloc[i-1]  # Previous
-            c2 = ohlc.iloc[i-2]  # Before previous
-            
-            # Doji
-            if self._is_doji(c0):
-                pattern_info['pattern'] = 'Doji'
-                pattern_info['signal'] = 'Neutral/Reversal'
-                patterns.append(pattern_info.copy())
-            
-            # Hammer
-            if self._is_hammer(c0):
-                pattern_info['pattern'] = 'Hammer'
-                pattern_info['signal'] = 'Bullish Reversal'
-                patterns.append(pattern_info.copy())
-            
-            # Shooting Star
-            if self._is_shooting_star(c0):
-                pattern_info['pattern'] = 'Shooting Star'
-                pattern_info['signal'] = 'Bearish Reversal'
-                patterns.append(pattern_info.copy())
-            
-            # Engulfing patterns
-            if self._is_bullish_engulfing(c1, c0):
-                pattern_info['pattern'] = 'Bullish Engulfing'
-                pattern_info['signal'] = 'Bullish Reversal'
-                patterns.append(pattern_info.copy())
-            
-            if self._is_bearish_engulfing(c1, c0):
-                pattern_info['pattern'] = 'Bearish Engulfing'
-                pattern_info['signal'] = 'Bearish Reversal'
-                patterns.append(pattern_info.copy())
-            
-            # Morning Star (3-candle pattern)
-            if self._is_morning_star(c2, c1, c0):
-                pattern_info['pattern'] = 'Morning Star'
-                pattern_info['signal'] = 'Bullish Reversal'
-                patterns.append(pattern_info.copy())
-            
-            # Evening Star
-            if self._is_evening_star(c2, c1, c0):
-                pattern_info['pattern'] = 'Evening Star'
-                pattern_info['signal'] = 'Bearish Reversal'
-                patterns.append(pattern_info.copy())
-        
-        self.patterns_found.extend(patterns)
-        return patterns
-    
-    def _is_doji(self, candle: pd.Series, threshold: float = 0.001) -> bool:
-        """Check if candle is a Doji"""
-        body = abs(candle['Close'] - candle['Open'])
-        range_size = candle['High'] - candle['Low']
-        return body / (range_size + 1e-10) < threshold
-    
-    def _is_hammer(self, candle: pd.Series) -> bool:
-        """Check if candle is a Hammer"""
-        body = abs(candle['Close'] - candle['Open'])
-        lower_shadow = min(candle['Open'], candle['Close']) - candle['Low']
-        upper_shadow = candle['High'] - max(candle['Open'], candle['Close'])
-        
-        return (lower_shadow > 2 * body and 
-                upper_shadow < body and
-                body > 0)
-    
-    def _is_shooting_star(self, candle: pd.Series) -> bool:
-        """Check if candle is a Shooting Star"""
-        body = abs(candle['Close'] - candle['Open'])
-        upper_shadow = candle['High'] - max(candle['Open'], candle['Close'])
-        lower_shadow = min(candle['Open'], candle['Close']) - candle['Low']
-        
-        return (upper_shadow > 2 * body and 
-                lower_shadow < body and
-                body > 0)
-    
-    def _is_bullish_engulfing(self, prev: pd.Series, curr: pd.Series) -> bool:
-        """Check for Bullish Engulfing pattern"""
-        prev_bearish = prev['Close'] < prev['Open']
-        curr_bullish = curr['Close'] > curr['Open']
-        
-        return (prev_bearish and curr_bullish and
-                curr['Open'] < prev['Close'] and
-                curr['Close'] > prev['Open'])
-    
-    def _is_bearish_engulfing(self, prev: pd.Series, curr: pd.Series) -> bool:
-        """Check for Bearish Engulfing pattern"""
-        prev_bullish = prev['Close'] > prev['Open']
-        curr_bearish = curr['Close'] < curr['Open']
-        
-        return (prev_bullish and curr_bearish and
-                curr['Open'] > prev['Close'] and
-                curr['Close'] < prev['Open'])
-    
-    def _is_morning_star(self, c1: pd.Series, c2: pd.Series, c3: pd.Series) -> bool:
-        """Check for Morning Star pattern"""
-        first_bearish = c1['Close'] < c1['Open']
-        second_small = abs(c2['Close'] - c2['Open']) < abs(c1['Close'] - c1['Open']) * 0.3
-        third_bullish = c3['Close'] > c3['Open']
-        
-        gap_down = c2['Open'] < c1['Close']
-        gap_up = c3['Open'] > c2['Close']
-        
-        return first_bearish and second_small and third_bullish and gap_down and gap_up
-    
-    def _is_evening_star(self, c1: pd.Series, c2: pd.Series, c3: pd.Series) -> bool:
-        """Check for Evening Star pattern"""
-        first_bullish = c1['Close'] > c1['Open']
-        second_small = abs(c2['Close'] - c2['Open']) < abs(c1['Close'] - c1['Open']) * 0.3
-        third_bearish = c3['Close'] < c3['Open']
-        
-        gap_up = c2['Open'] > c1['Close']
-        gap_down = c3['Open'] < c2['Close']
-        
-        return first_bullish and second_small and third_bearish and gap_up and gap_down
-    
-    def detect_chart_patterns(self, prices: np.ndarray, dates: pd.DatetimeIndex) -> List[Dict]:
-        """
-        Detect chart patterns (Head & Shoulders, Double Top/Bottom, etc.)
-        
-        Args:
-            prices: Price series
-            dates: Date index
-            
-        Returns:
-            List of detected chart patterns
-        """
-        patterns = []
-        
-        # Find local maxima and minima
-        maxima_idx = argrelextrema(prices, np.greater, order=5)[0]
-        minima_idx = argrelextrema(prices, np.less, order=5)[0]
-        
-        # Head and Shoulders
-        hs_patterns = self._find_head_shoulders(prices, maxima_idx, dates)
-        patterns.extend(hs_patterns)
-        
-        # Inverse Head and Shoulders
-        ihs_patterns = self._find_inverse_head_shoulders(prices, minima_idx, dates)
-        patterns.extend(ihs_patterns)
-        
-        # Double Top
-        double_top = self._find_double_top(prices, maxima_idx, dates)
-        patterns.extend(double_top)
-        
-        # Double Bottom
-        double_bottom = self._find_double_bottom(prices, minima_idx, dates)
-        patterns.extend(double_bottom)
-        
-        # Triangle patterns
-        triangles = self._find_triangles(prices, maxima_idx, minima_idx, dates)
-        patterns.extend(triangles)
-        
-        return patterns
-    
-    def _find_head_shoulders(self, prices: np.ndarray, peaks: np.ndarray, dates: pd.DatetimeIndex) -> List[Dict]:
-        """Detect Head and Shoulders pattern"""
-        patterns = []
-        
-        for i in range(len(peaks) - 2):
-            left_shoulder = peaks[i]
-            head = peaks[i + 1]
-            right_shoulder = peaks[i + 2]
-            
-            # Check if head is higher than shoulders
-            if (prices[head] > prices[left_shoulder] and 
-                prices[head] > prices[right_shoulder] and
-                abs(prices[left_shoulder] - prices[right_shoulder]) / prices[head] < 0.03):
-                
-                patterns.append({
-                    'pattern': 'Head and Shoulders',
-                    'signal': 'Bearish Reversal',
-                    'left_shoulder': {'date': dates[left_shoulder], 'price': prices[left_shoulder]},
-                    'head': {'date': dates[head], 'price': prices[head]},
-                    'right_shoulder': {'date': dates[right_shoulder], 'price': prices[right_shoulder]},
-                    'neckline': float(min(prices[left_shoulder], prices[right_shoulder]))
-                })
-        
-        return patterns
-    
-    def _find_inverse_head_shoulders(self, prices: np.ndarray, troughs: np.ndarray, dates: pd.DatetimeIndex) -> List[Dict]:
-        """Detect Inverse Head and Shoulders pattern"""
-        patterns = []
-        
-        for i in range(len(troughs) - 2):
-            left_shoulder = troughs[i]
-            head = troughs[i + 1]
-            right_shoulder = troughs[i + 2]
-            
-            if (prices[head] < prices[left_shoulder] and 
-                prices[head] < prices[right_shoulder] and
-                abs(prices[left_shoulder] - prices[right_shoulder]) / prices[head] < 0.03):
-                
-                patterns.append({
-                    'pattern': 'Inverse Head and Shoulders',
-                    'signal': 'Bullish Reversal',
-                    'left_shoulder': {'date': dates[left_shoulder], 'price': prices[left_shoulder]},
-                    'head': {'date': dates[head], 'price': prices[head]},
-                    'right_shoulder': {'date': dates[right_shoulder], 'price': prices[right_shoulder]},
-                    'neckline': float(max(prices[left_shoulder], prices[right_shoulder]))
-                })
-        
-        return patterns
-    
-    def _find_double_top(self, prices: np.ndarray, peaks: np.ndarray, dates: pd.DatetimeIndex) -> List[Dict]:
-        """Detect Double Top pattern"""
-        patterns = []
-        
-        for i in range(len(peaks) - 1):
-            peak1 = peaks[i]
-            peak2 = peaks[i + 1]
-            
-            # Check if peaks are similar in height
-            if abs(prices[peak1] - prices[peak2]) / prices[peak1] < 0.02:
-                patterns.append({
-                    'pattern': 'Double Top',
-                    'signal': 'Bearish Reversal',
-                    'first_top': {'date': dates[peak1], 'price': prices[peak1]},
-                    'second_top': {'date': dates[peak2], 'price': prices[peak2]}
-                })
-        
-        return patterns
-    
-    def _find_double_bottom(self, prices: np.ndarray, troughs: np.ndarray, dates: pd.DatetimeIndex) -> List[Dict]:
-        """Detect Double Bottom pattern"""
-        patterns = []
-        
-        for i in range(len(troughs) - 1):
-            trough1 = troughs[i]
-            trough2 = troughs[i + 1]
-            
-            if abs(prices[trough1] - prices[trough2]) / prices[trough1] < 0.02:
-                patterns.append({
-                    'pattern': 'Double Bottom',
-                    'signal': 'Bullish Reversal',
-                    'first_bottom': {'date': dates[trough1], 'price': prices[trough1]},
-                    'second_bottom': {'date': dates[trough2], 'price': prices[trough2]}
-                })
-        
-        return patterns
-    
-    def _find_triangles(self, prices: np.ndarray, peaks: np.ndarray, troughs: np.ndarray, dates: pd.DatetimeIndex) -> List[Dict]:
-        """Detect triangle patterns (ascending, descending, symmetrical)"""
-        patterns = []
-        
-        if len(peaks) >= 2 and len(troughs) >= 2:
-            # Simple triangle detection based on trendlines
-            peak_slope = (prices[peaks[-1]] - prices[peaks[0]]) / (peaks[-1] - peaks[0])
-            trough_slope = (prices[troughs[-1]] - prices[troughs[0]]) / (troughs[-1] - troughs[0])
-            
-            if abs(peak_slope) < 0.001 and trough_slope > 0:
-                patterns.append({
-                    'pattern': 'Ascending Triangle',
-                    'signal': 'Bullish Continuation'
-                })
-            elif abs(trough_slope) < 0.001 and peak_slope < 0:
-                patterns.append({
-                    'pattern': 'Descending Triangle',
-                    'signal': 'Bearish Continuation'
-                })
-            elif peak_slope < 0 and trough_slope > 0:
-                patterns.append({
-                    'pattern': 'Symmetrical Triangle',
-                    'signal': 'Breakout Expected'
-                })
-        
-        return patterns
-    
-    def ml_pattern_clustering(self, price_windows: np.ndarray, n_clusters: int = 5) -> Dict:
-        """
-        Use ML to cluster similar price patterns using DTW
-        
-        Args:
-            price_windows: Array of price windows (n_samples, window_size)
-            n_clusters: Number of clusters
-            
-        Returns:
-            Dictionary with cluster information
-        """
-        # Normalize windows
-        normalized_windows = []
-        for window in price_windows:
-            if len(window) > 0 and np.std(window) > 0:
-                norm_window = (window - np.mean(window)) / np.std(window)
-                normalized_windows.append(norm_window)
-        
-        if len(normalized_windows) == 0:
-            return {}
-        
-        normalized_windows = np.array(normalized_windows)
-        
-        # Time series K-means with DTW
-        self.cluster_model = TimeSeriesKMeans(
-            n_clusters=n_clusters,
-            metric="dtw",
-            max_iter=10,
-            random_state=config.ML_RANDOM_STATE
-        )
-        
-        labels = self.cluster_model.fit_predict(normalized_windows)
-        
-        # Analyze clusters
-        cluster_info = {}
-        for cluster_id in range(n_clusters):
-            cluster_windows = normalized_windows[labels == cluster_id]
-            
-            if len(cluster_windows) > 0:
-                cluster_info[f'cluster_{cluster_id}'] = {
-                    'size': int(np.sum(labels == cluster_id)),
-                    'centroid': self.cluster_model.cluster_centers_[cluster_id].flatten().tolist(),
-                    'avg_shape': np.mean(cluster_windows, axis=0).tolist()
-                }
-        
-        self.clusters = {
-            'labels': labels.tolist(),
-            'cluster_info': cluster_info,
-            'n_clusters': n_clusters
-        }
-        
-        return self.clusters
-    
-    def find_similar_patterns(self, current_window: np.ndarray, historical_windows: np.ndarray, top_n: int = 10) -> List[Dict]:
-        """
-        Find historical patterns similar to current pattern using DTW
-        
-        Args:
-            current_window: Current price pattern
-            historical_windows: Historical price patterns
-            top_n: Number of similar patterns to return
-            
-        Returns:
-            List of similar patterns with distances
-        """
-        # Normalize current window
-        if np.std(current_window) > 0:
-            norm_current = (current_window - np.mean(current_window)) / np.std(current_window)
-        else:
-            norm_current = current_window
-        
-        # Calculate DTW distances
-        distances = []
-        for i, hist_window in enumerate(historical_windows):
-            if np.std(hist_window) > 0:
-                norm_hist = (hist_window - np.mean(hist_window)) / np.std(hist_window)
-            else:
-                norm_hist = hist_window
-            
-            distance = dtw(norm_current, norm_hist)
-            distances.append({'index': i, 'distance': float(distance)})
-        
-        # Sort by distance and return top N
-        distances.sort(key=lambda x: x['distance'])
-        return distances[:top_n]

src/pdf_report.py

@@ -1,238 +0,0 @@
-"""
-PDF Report Generation Module
-"""
-from reportlab.lib.pagesizes import A4, letter
-from reportlab.lib import colors
-from reportlab.lib.units import inch
-from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak, Image
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT
-from datetime import datetime
-import os
-from typing import Dict, List
-import numpy as np
-
-class PDFReportGenerator:
-    """
-    Generate comprehensive PDF reports with charts and analysis
-    """
-    
-    def __init__(self, filename: str = None):
-        if filename is None:
-            filename = f"analysis_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
-        
-        self.filename = filename
-        self.doc = SimpleDocTemplate(
-            filename,
-            pagesize=A4,
-            rightMargin=0.75*inch,
-            leftMargin=0.75*inch,
-            topMargin=1*inch,
-            bottomMargin=0.75*inch
-        )
-        self.story = []
-        self.styles = getSampleStyleSheet()
-        self._setup_custom_styles()
-    
-    def _setup_custom_styles(self):
-        """Setup custom paragraph styles"""
-        self.styles.add(ParagraphStyle(
-            name='CustomTitle',
-            parent=self.styles['Heading1'],
-            fontSize=24,
-            textColor=colors.HexColor('#1976d2'),
-            spaceAfter=30,
-            alignment=TA_CENTER
-        ))
-        
-        self.styles.add(ParagraphStyle(
-            name='SectionHeader',
-            parent=self.styles['Heading2'],
-            fontSize=16,
-            textColor=colors.HexColor('#1976d2'),
-            spaceAfter=12,
-            spaceBefore=12
-        ))
-    
-    def add_title_page(self, symbol: str, analysis_date: str):
-        """Add title page"""
-        title = Paragraph(
-            f"<b>Quantitative Finance Analysis Report</b>",
-            self.styles['CustomTitle']
-        )
-        self.story.append(title)
-        self.story.append(Spacer(1, 0.3*inch))
-        
-        subtitle = Paragraph(
-            f"<b>Symbol:</b> {symbol}<br/>"
-            f"<b>Analysis Date:</b> {analysis_date}<br/>"
-            f"<b>Report Generated:</b> {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
-            self.styles['Normal']
-        )
-        self.story.append(subtitle)
-        self.story.append(PageBreak())
-    
-    def add_executive_summary(self, summary_data: Dict):
-        """Add executive summary section"""
-        self.story.append(Paragraph("Executive Summary", self.styles['SectionHeader']))
-        
-        summary_text = f"""
-        <b>Current Price:</b> ${summary_data.get('current_price', 0):.2f}<br/>
-        <b>Market Regime:</b> {summary_data.get('market_regime', 'N/A')}<br/>
-        <b>Volatility:</b> {summary_data.get('volatility', 0):.2%}<br/>
-        <b>Momentum Status:</b> {summary_data.get('momentum_status', 'N/A')}<br/>
-        <b>ML Prediction Accuracy:</b> {summary_data.get('ml_r2', 0):.2%}<br/>
-        """
-        
-        self.story.append(Paragraph(summary_text, self.styles['Normal']))
-        self.story.append(Spacer(1, 0.2*inch))
-    
-    def add_frequency_analysis(self, spectral_data: Dict):
-        """Add spectral analysis section"""
-        self.story.append(Paragraph("Multi-Frequency Spectral Analysis", self.styles['SectionHeader']))
-        
-        for band_name, band_data in spectral_data.items():
-            self.story.append(Paragraph(f"<b>{band_name.upper()} Frequency Band</b>", self.styles['Heading3']))
-            
-            # Dominant frequencies table
-            if 'dominant_frequencies' in band_data and band_data['dominant_frequencies']:
-                freq_data = [['Frequency (cycles/day)', 'Period (days)', 'Amplitude', 'Significance']]
-                
-                for freq in band_data['dominant_frequencies'][:3]:
-                    freq_data.append([
-                        f"{freq['frequency']:.4f}",
-                        f"{freq['period_days']:.1f}",
-                        f"{freq['amplitude']:.0f}",
-                        f"{freq['significance']:.2%}"
-                    ])
-                
-                table = Table(freq_data)
-                table.setStyle(TableStyle([
-                    ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
-                    ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
-                    ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
-                    ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
-                    ('FONTSIZE', (0, 0), (-1, 0), 10),
-                    ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
-                    ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
-                    ('GRID', (0, 0), (-1, -1), 1, colors.black)
-                ]))
-                
-                self.story.append(table)
-                self.story.append(Spacer(1, 0.2*inch))
-    
-    def add_monte_carlo_results(self, mc_stats: Dict):
-        """Add Monte Carlo simulation results"""
-        self.story.append(Paragraph("Monte Carlo Simulation Results", self.styles['SectionHeader']))
-        
-        for model_name, stats in mc_stats.items():
-            self.story.append(Paragraph(f"<b>{model_name.upper()} Model</b>", self.styles['Heading3']))
-            
-            stats_text = f"""
-            <b>Expected Final Price:</b> ${stats.get('mean_final_price', 0):.2f}<br/>
-            <b>Median Price:</b> ${stats.get('median_final_price', 0):.2f}<br/>
-            <b>95% Confidence Interval:</b> ${stats.get('percentile_5', 0):.2f} - ${stats.get('percentile_95', 0):.2f}<br/>
-            <b>Probability of Profit:</b> {stats.get('prob_profit', 0):.2%}<br/>
-            <b>Expected Return:</b> {stats.get('expected_return', 0):.2%}<br/>
-            <b>Value at Risk (95%):</b> ${stats.get('var_95', 0):.2f}<br/>
-            <b>Conditional VaR:</b> ${stats.get('cvar_95', 0):.2f}<br/>
-            """
-            
-            self.story.append(Paragraph(stats_text, self.styles['Normal']))
-            self.story.append(Spacer(1, 0.15*inch))
-    
-    def add_bayesian_analysis(self, bayesian_data: Dict):
-        """Add Bayesian analysis results"""
-        self.story.append(Paragraph("Bayesian Inference Results", self.styles['SectionHeader']))
-        
-        if 'regime_probabilities' in bayesian_data:
-            probs = bayesian_data['regime_probabilities']
-            
-            regime_text = f"""
-            <b>Market Regime Probabilities:</b><br/>
-            • Range-Bound: {probs.get('range_bound', 0):.1%}<br/>
-            • Trending: {probs.get('trending', 0):.1%}<br/>
-            • High Volatility: {probs.get('high_volatility', 0):.1%}<br/>
-            """
-            
-            self.story.append(Paragraph(regime_text, self.styles['Normal']))
-        
-        if 'optimal_params' in bayesian_data:
-            self.story.append(Paragraph("<b>Optimized Parameters (Bayesian):</b>", self.styles['Heading3']))
-            
-            params = bayesian_data['optimal_params']
-            param_data = [['Parameter', 'Mean', 'Std Dev', '95% HDI']]
-            
-            for param_name, param_info in params.items():
-                hdi = param_info.get('hdi_95', (0, 0))
-                param_data.append([
-                    param_name.replace('_', ' ').title(),
-                    f"{param_info.get('mean', 0):.4f}",
-                    f"{param_info.get('std', 0):.4f}",
-                    f"[{hdi[0]:.4f}, {hdi[1]:.4f}]"
-                ])
-            
-            table = Table(param_data)
-            table.setStyle(TableStyle([
-                ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
-                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
-                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
-                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
-                ('GRID', (0, 0), (-1, -1), 1, colors.black)
-            ]))
-            
-            self.story.append(table)
-    
-    def add_pattern_detection(self, patterns: List[Dict]):
-        """Add detected patterns"""
-        self.story.append(Paragraph("Pattern Recognition Results", self.styles['SectionHeader']))
-        
-        if not patterns:
-            self.story.append(Paragraph("No significant patterns detected in the analysis period.", 
-                                      self.styles['Normal']))
-            return
-        
-        # Group by pattern type
-        pattern_counts = {}
-        for p in patterns:
-            ptype = p.get('pattern', 'Unknown')
-            pattern_counts[ptype] = pattern_counts.get(ptype, 0) + 1
-        
-        pattern_text = "<b>Detected Patterns:</b><br/>"
-        for ptype, count in pattern_counts.items():
-            pattern_text += f"• {ptype}: {count} occurrence(s)<br/>"
-        
-        self.story.append(Paragraph(pattern_text, self.styles['Normal']))
-    
-    def add_chart_image(self, image_path: str, width: float = 6*inch):
-        """Add chart image to report"""
-        if os.path.exists(image_path):
-            img = Image(image_path, width=width, height=width*0.6)
-            self.story.append(img)
-            self.story.append(Spacer(1, 0.2*inch))
-    
-    def add_risk_disclaimer(self):
-        """Add risk disclaimer"""
-        self.story.append(PageBreak())
-        self.story.append(Paragraph("Risk Disclaimer", self.styles['SectionHeader']))
-        
-        disclaimer = """
-        <b>Important Notice:</b> This report is for informational and educational purposes only. 
-        It does not constitute financial advice, investment recommendations, or an offer to buy or sell securities.
-        <br/><br/>
-        Past performance is not indicative of future results. All investments carry risk, including potential loss of principal.
-        The models and predictions presented in this report are based on historical data and assumptions that may not hold in the future.
-        <br/><br/>
-        Always conduct your own research and consult with a qualified financial advisor before making investment decisions.
-        <br/><br/>
-        <b>Model Limitations:</b> The quantitative models used in this analysis have inherent limitations and may not account 
-        for all market factors, unexpected events, or regime changes. Results should be interpreted with appropriate caution.
-        """
-        
-        self.story.append(Paragraph(disclaimer, self.styles['Normal']))
-    
-    def generate(self):
-        """Generate the PDF report"""
-        self.add_risk_disclaimer()
-        self.doc.build(self.story)
-        return self.filename

src/spectral_analyzer.py

@@ -1,262 +0,0 @@
-"""
-Advanced spectral analysis with multi-frequency decomposition
-"""
-import numpy as np
-import pandas as pd
-from scipy import signal
-from scipy.fft import fft, fftfreq
-from scipy.stats import norm
-from typing import Dict, List, Tuple
-from src.config import config, FrequencyBand
-
-class SpectralAnalyzer:
-    """
-    Multi-frequency spectral analysis engine
-    Decomposes price signals into Low, Mid, and High frequency bands
-    """
-    
-    def __init__(self):
-        self.original_prices = None
-        self.filtered_bands = {}  # Stores filtered prices for each band
-        self.spectrum_bands = {}  # Stores spectrum for each band
-        self.frequencies_bands = {}  # Stores frequencies for each band
-        self.dominant_frequencies = {}  # Stores dominant freqs per band
-        
-    def analyze(self, prices: np.ndarray) -> Dict:
-        """
-        Perform complete spectral analysis across all frequency bands
-        
-        Args:
-            prices: Array of price data
-            
-        Returns:
-            Dictionary containing analysis results for all bands
-        """
-        self.original_prices = prices
-        results = {}
-        
-        for band_name, band_config in config.FREQUENCY_BANDS.items():
-            # Apply band-specific filtering
-            filtered = self._apply_bandpass_filter(prices, band_config)
-            self.filtered_bands[band_name] = filtered
-            
-            # Perform spectral analysis
-            spectrum, frequencies = self._perform_fft(filtered)
-            self.spectrum_bands[band_name] = spectrum
-            self.frequencies_bands[band_name] = frequencies
-            
-            # Find dominant frequencies
-            dominant = self._find_dominant_frequencies(
-                spectrum, frequencies, band_config, top_n=5
-            )
-            self.dominant_frequencies[band_name] = dominant
-            
-            results[band_name] = {
-                'filtered_prices': filtered,
-                'spectrum': spectrum,
-                'frequencies': frequencies,
-                'dominant_frequencies': dominant,
-                'band_config': band_config
-            }
-        
-        return results
-    
-    def _apply_bandpass_filter(self, prices: np.ndarray, band: FrequencyBand) -> np.ndarray:
-        """
-        Apply butterworth bandpass filter for specific frequency band
-        
-        Args:
-            prices: Input price series
-            band: Frequency band configuration
-            
-        Returns:
-            Filtered price series
-        """
-        nyquist = 0.5
-        low_cutoff = band.cutoff_range[0] / nyquist
-        high_cutoff = band.cutoff_range[1] / nyquist
-        
-        # Ensure cutoffs are in valid range (0, 1)
-        low_cutoff = max(0.001, min(0.999, low_cutoff))
-        high_cutoff = max(0.001, min(0.999, high_cutoff))
-        
-        if low_cutoff >= high_cutoff:
-            # Use lowpass filter instead
-            b, a = signal.butter(band.filter_order, high_cutoff, btype='low')
-        else:
-            b, a = signal.butter(band.filter_order, [low_cutoff, high_cutoff], btype='band')
-        
-        filtered = signal.filtfilt(b, a, prices)
-        return filtered
-    
-    def _perform_fft(self, prices: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-        """
-        Perform Fast Fourier Transform
-        
-        Returns:
-            Tuple of (spectrum, frequencies)
-        """
-        n = len(prices)
-        spectrum = fft(prices)
-        frequencies = fftfreq(n, d=1.0)
-        
-        # Keep only positive frequencies
-        positive_mask = frequencies > 0
-        spectrum = spectrum[positive_mask]
-        frequencies = frequencies[positive_mask]
-        
-        return spectrum, frequencies
-    
-    def _find_dominant_frequencies(
-        self, 
-        spectrum: np.ndarray, 
-        frequencies: np.ndarray, 
-        band: FrequencyBand,
-        top_n: int = 5
-    ) -> List[Dict]:
-        """
-        Identify dominant frequencies with statistical significance
-        
-        Returns:
-            List of dominant frequency components
-        """
-        magnitude = np.abs(spectrum)
-        
-        # Estimate noise floor
-        noise_floor = np.percentile(magnitude, 75)
-        
-        # Find significant frequencies
-        significant_mask = magnitude > noise_floor * 1.5
-        significant_freqs = frequencies[significant_mask]
-        significant_mags = magnitude[significant_mask]
-        
-        if len(significant_freqs) == 0:
-            significant_freqs = frequencies
-            significant_mags = magnitude
-        
-        # Get top N by magnitude
-        top_indices = np.argsort(significant_mags)[-top_n:][::-1]
-        
-        dominant_freqs = []
-        for idx in top_indices:
-            freq = significant_freqs[idx]
-            amplitude = significant_mags[idx]
-            period_days = 1.0 / freq if freq != 0 else np.inf
-            
-            # Get phase
-            phase_idx = np.where(frequencies == freq)[0]
-            if len(phase_idx) > 0:
-                phase = np.angle(spectrum[phase_idx[0]])
-            else:
-                phase = 0.0
-            
-            # Calculate statistical significance
-            z_score = (amplitude - noise_floor) / (np.std(magnitude) + 1e-10)
-            p_value = 1 - norm.cdf(z_score)
-            significance = 1 - p_value
-            
-            dominant_freqs.append({
-                'frequency': float(freq),
-                'period_days': float(period_days),
-                'amplitude': float(amplitude),
-                'phase': float(phase),
-                'significance': float(significance),
-                'z_score': float(z_score),
-                'band': band.name
-            })
-        
-        return dominant_freqs
-    
-    def calculate_band_momentum(self, band_name: str, window_size: int = 30) -> np.ndarray:
-        """
-        Calculate momentum signal for specific frequency band
-        
-        Args:
-            band_name: Name of frequency band ('low', 'mid', 'high')
-            window_size: Rolling window for momentum calculation
-            
-        Returns:
-            Momentum signal array
-        """
-        if band_name not in self.filtered_bands:
-            raise ValueError(f"Band '{band_name}' not analyzed yet")
-        
-        filtered_prices = self.filtered_bands[band_name]
-        dominant_freqs = self.dominant_frequencies[band_name]
-        
-        if not dominant_freqs:
-            return self._simple_momentum(filtered_prices, window_size)
-        
-        momentum_values = []
-        
-        # Calculate weights based on amplitude and significance
-        total_weight = sum(f['amplitude'] * f['significance'] for f in dominant_freqs[:3])
-        weights = [(f['amplitude'] * f['significance']) / total_weight for f in dominant_freqs[:3]]
-        
-        for i in range(window_size, len(filtered_prices)):
-            window_data = filtered_prices[i-window_size:i]
-            window_spectrum = fft(window_data)
-            window_freqs = fftfreq(len(window_data), d=1.0)
-            
-            weighted_momentum = 0
-            for j, freq_info in enumerate(dominant_freqs[:3]):
-                closest_idx = np.argmin(np.abs(window_freqs - freq_info['frequency']))
-                phase = np.angle(window_spectrum[closest_idx])
-                
-                # Calculate distance to next peak
-                next_peak_distance = (2*np.pi - phase) / (2*np.pi)
-                freq_momentum = np.cos(phase) * (1 - next_peak_distance)
-                
-                weighted_momentum += freq_momentum * weights[j]
-            
-            momentum_values.append(weighted_momentum)
-        
-        # Prepend zeros for initial window
-        momentum_signal = np.concatenate([
-            np.zeros(window_size),
-            np.array(momentum_values)
-        ])
-        
-        return momentum_signal
-    
-    def _simple_momentum(self, prices: np.ndarray, window_size: int) -> np.ndarray:
-        """Fallback simple momentum calculation"""
-        momentum = np.zeros(len(prices))
-        
-        for i in range(window_size, len(prices)):
-            window = prices[i-window_size:i]
-            momentum[i] = (prices[i] - np.mean(window)) / (np.std(window) + 1e-10)
-        
-        return momentum
-    
-    def get_multi_band_momentum(self, window_size: int = 30) -> Dict[str, np.ndarray]:
-        """
-        Calculate momentum for all frequency bands
-        
-        Returns:
-            Dictionary mapping band names to momentum signals
-        """
-        momentum_signals = {}
-        
-        for band_name in self.filtered_bands.keys():
-            momentum_signals[band_name] = self.calculate_band_momentum(band_name, window_size)
-        
-        return momentum_signals
-    
-    def get_composite_momentum(self, window_size: int = 30) -> np.ndarray:
-        """
-        Calculate composite momentum combining all frequency bands
-        
-        Returns:
-            Composite momentum signal
-        """
-        band_momentums = self.get_multi_band_momentum(window_size)
-        
-        # Weight bands: Low=0.5, Mid=0.3, High=0.2 (emphasize longer-term trends)
-        weights = {'low': 0.5, 'mid': 0.3, 'high': 0.2}
-        
-        composite = np.zeros(len(self.original_prices))
-        for band_name, momentum in band_momentums.items():
-            composite += momentum * weights.get(band_name, 0.33)
-        
-        return composite

src/visualization.py

@@ -1,508 +0,0 @@
-"""
-Advanced visualization module using Plotly
-"""
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import numpy as np
-import pandas as pd
-from typing import Dict, List, Tuple
-from src.config import config
-
-class Visualizer:
-    """Create professional interactive visualizations"""
-    
-    def __init__(self):
-        self.figures = {}
-        
-    def create_price_decomposition_chart(
-        self,
-        dates: pd.DatetimeIndex,
-        original_prices: np.ndarray,
-        spectral_results: Dict,
-        buy_signals: List[Dict] = None
-    ) -> go.Figure:
-        """
-        Chart 1: Price decomposition with anti-aliased bands and buy signals
-        """
-        fig = go.Figure()
-        
-        # Original price (raw)
-        fig.add_trace(go.Scatter(
-            x=dates,
-            y=original_prices,
-            name='Original Price',
-            line=dict(color='rgba(128,128,128,0.3)', width=1),
-            hovertemplate='%{x}<br>Price: $%{y:.2f}<extra></extra>'
-        ))
-        
-        # Anti-aliased filtered bands
-        colors = {
-            'low': '#0066CC',    # Blue
-            'mid': '#00AA44',    # Green
-            'high': '#EE4400'    # Red
-        }
-        
-        for band_name, result in spectral_results.items():
-            filtered = result['filtered_prices']
-            band_config = result['band_config']
-            
-            fig.add_trace(go.Scatter(
-                x=dates,
-                y=filtered,
-                name=f'{band_config.name}',
-                line=dict(color=colors[band_name], width=2.5),
-                hovertemplate=f'{band_config.name}<br>%{{x}}<br>Filtered: $%{{y:.2f}}<extra></extra>'
-            ))
-        
-        # Add buy signals
-        if buy_signals:
-            signal_dates = [pd.to_datetime(s['date']) for s in buy_signals]
-            signal_prices = [s['price'] for s in buy_signals]
-            
-            fig.add_trace(go.Scatter(
-                x=signal_dates,
-                y=signal_prices,
-                mode='markers',
-                name='Buy Signals',
-                marker=dict(
-                    size=15,
-                    color='lime',
-                    symbol='triangle-up',
-                    line=dict(color='darkgreen', width=2)
-                ),
-                hovertemplate='BUY SIGNAL<br>%{x}<br>Price: $%{y:.2f}<extra></extra>'
-            ))
-        
-        fig.update_layout(
-            title='Multi-Frequency Price Decomposition with Anti-Aliasing',
-            xaxis_title='Date',
-            yaxis_title='Price ($)',
-            hovermode='x unified',
-            height=600,
-            template='plotly_white',
-            legend=dict(x=0.01, y=0.99, bgcolor='rgba(255,255,255,0.8)')
-        )
-        
-        return fig
-    
-    def create_frequency_spectrum_chart(self, spectral_results: Dict) -> go.Figure:
-        """
-        Chart 2: Frequency spectrum with dominant frequencies highlighted
-        """
-        fig = make_subplots(
-            rows=3, cols=1,
-            subplot_titles=['Low Frequency Spectrum', 'Mid Frequency Spectrum', 'High Frequency Spectrum'],
-            vertical_spacing=0.1
-        )
-        
-        colors = {'low': '#0066CC', 'mid': '#00AA44', 'high': '#EE4400'}
-        row_map = {'low': 1, 'mid': 2, 'high': 3}
-        
-        for band_name, result in spectral_results.items():
-            frequencies = result['frequencies']
-            magnitude = np.abs(result['spectrum'])
-            dominant_freqs = result['dominant_frequencies']
-            
-            row = row_map[band_name]
-            
-            # Spectrum line
-            fig.add_trace(go.Scatter(
-                x=frequencies,
-                y=magnitude,
-                name=f'{band_name.capitalize()} Spectrum',
-                line=dict(color=colors[band_name], width=2),
-                fill='tozeroy',
-                fillcolor=f'rgba{tuple(list(int(colors[band_name][i:i+2], 16) for i in (1, 3, 5)) + [0.3])}',
-                hovertemplate='Freq: %{x:.4f} cycles/day<br>Magnitude: %{y:.0f}<extra></extra>'
-            ), row=row, col=1)
-            
-            # Mark dominant frequencies
-            if dominant_freqs:
-                dom_freqs = [d['frequency'] for d in dominant_freqs[:3]]
-                dom_mags = [d['amplitude'] for d in dominant_freqs[:3]]
-                dom_periods = [d['period_days'] for d in dominant_freqs[:3]]
-                
-                fig.add_trace(go.Scatter(
-                    x=dom_freqs,
-                    y=dom_mags,
-                    mode='markers+text',
-                    name=f'{band_name.capitalize()} Dominant',
-                    marker=dict(size=12, color='red', symbol='star'),
-                    text=[f'{p:.1f}d' for p in dom_periods],
-                    textposition='top center',
-                    hovertemplate='Period: %{text}<br>Freq: %{x:.4f}<br>Amplitude: %{y:.0f}<extra></extra>'
-                ), row=row, col=1)
-        
-        fig.update_xaxes(title_text='Frequency (cycles/day)')
-        fig.update_yaxes(title_text='Magnitude')
-        
-        fig.update_layout(
-            height=900,
-            title_text='Frequency Domain Analysis - Dominant Cycles Identified',
-            showlegend=True,
-            template='plotly_white'
-        )
-        
-        return fig
-    
-    def create_phase_angle_chart(self, spectral_results: Dict, dates: pd.DatetimeIndex) -> go.Figure:
-        """
-        Chart 3: Phase angle evolution over time
-        """
-        fig = make_subplots(
-            rows=3, cols=1,
-            subplot_titles=['Low Frequency Phase', 'Mid Frequency Phase', 'High Frequency Phase'],
-            vertical_spacing=0.1
-        )
-        
-        colors = {'low': '#0066CC', 'mid': '#00AA44', 'high': '#EE4400'}
-        row_map = {'low': 1, 'mid': 2, 'high': 3}
-        
-        for band_name, result in spectral_results.items():
-            dominant_freqs = result['dominant_frequencies']
-            if not dominant_freqs:
-                continue
-            
-            # Get the most dominant frequency
-            main_freq = dominant_freqs[0]
-            freq_val = main_freq['frequency']
-            period = main_freq['period_days']
-            
-            row = row_map[band_name]
-            
-            # Calculate phase angle over time
-            n_points = len(dates)
-            phase_angles = np.zeros(n_points)
-            
-            for i in range(n_points):
-                phase_angles[i] = (main_freq['phase'] + 2 * np.pi * freq_val * i) % (2 * np.pi)
-            
-            # Convert to degrees
-            phase_degrees = np.degrees(phase_angles)
-            
-            # Phase angle line
-            fig.add_trace(go.Scatter(
-                x=dates,
-                y=phase_degrees,
-                name=f'{band_name.capitalize()} Phase',
-                line=dict(color=colors[band_name], width=2),
-                hovertemplate='%{x}<br>Phase: %{y:.1f}°<extra></extra>'
-            ), row=row, col=1)
-            
-            # Add horizontal lines for key phases
-            fig.add_hline(y=0, line_dash="dash", line_color="gray", opacity=0.5, row=row, col=1)
-            fig.add_hline(y=90, line_dash="dash", line_color="green", opacity=0.5, row=row, col=1)
-            fig.add_hline(y=180, line_dash="dash", line_color="gray", opacity=0.5, row=row, col=1)
-            fig.add_hline(y=270, line_dash="dash", line_color="red", opacity=0.5, row=row, col=1)
-            
-            # Add annotations
-            fig.add_annotation(
-                x=dates[-1], y=phase_degrees[-1],
-                text=f"Period: {period:.1f}d",
-                showarrow=True,
-                arrowhead=2,
-                row=row, col=1
-            )
-        
-        fig.update_xaxes(title_text='Date')
-        fig.update_yaxes(title_text='Phase Angle (degrees)', range=[0, 360])
-        
-        fig.update_layout(
-            height=900,
-            title_text='Phase Angle Evolution - Cycle Timing Analysis',
-            template='plotly_white',
-            showlegend=True
-        )
-        
-        return fig
-    
-    def create_momentum_signals_chart(
-        self,
-        dates: pd.DatetimeIndex,
-        momentum_signals: Dict[str, np.ndarray],
-        buy_signals: List[Dict] = None
-    ) -> go.Figure:
-        """
-        Chart 4: Momentum signals across all frequency bands
-        """
-        fig = go.Figure()
-        
-        colors = {'low': '#0066CC', 'mid': '#00AA44', 'high': '#EE4400', 'composite': '#9933FF'}
-        
-        for band_name, momentum in momentum_signals.items():
-            fig.add_trace(go.Scatter(
-                x=dates,
-                y=momentum,
-                name=f'{band_name.capitalize()} Momentum',
-                line=dict(color=colors.get(band_name, 'gray'), width=2),
-                hovertemplate=f'{band_name.capitalize()}<br>%{{x}}<br>Momentum: %{{y:.3f}}<extra></extra>'
-            ))
-        
-        # Zero line
-        fig.add_hline(y=0, line_dash="dash", line_color="black", opacity=0.5)
-        
-        # Threshold lines
-        fig.add_hline(y=0.5, line_dash="dot", line_color="green", opacity=0.3, annotation_text="Bullish")
-        fig.add_hline(y=-0.5, line_dash="dot", line_color="red", opacity=0.3, annotation_text="Bearish")
-        
-        # Mark buy signals
-        if buy_signals:
-            signal_dates = [pd.to_datetime(s['date']) for s in buy_signals]
-            signal_momentum = [s['momentum'] for s in buy_signals]
-            
-            fig.add_trace(go.Scatter(
-                x=signal_dates,
-                y=signal_momentum,
-                mode='markers',
-                name='Buy Signal Points',
-                marker=dict(size=12, color='lime', symbol='star', line=dict(color='darkgreen', width=1)),
-                hovertemplate='BUY SIGNAL<br>%{x}<br>Momentum: %{y:.3f}<extra></extra>'
-            ))
-        
-        fig.update_layout(
-            title='Multi-Frequency Momentum Signals',
-            xaxis_title='Date',
-            yaxis_title='Momentum Value',
-            hovermode='x unified',
-            height=600,
-            template='plotly_white',
-            legend=dict(x=0.01, y=0.99, bgcolor='rgba(255,255,255,0.8)')
-        )
-        
-        return fig
-    
-    def create_monte_carlo_chart(self, mc_results: Dict, current_price: float) -> go.Figure:
-        """
-        Chart 5: Monte Carlo simulation paths with confidence bands
-        """
-        fig = go.Figure()
-        
-        model_colors = {
-            'gbm': '#0066CC',
-            'jump_diffusion': '#FF6600',
-            'garch': '#00AA44',
-            'heston': '#9933FF'
-        }
-        
-        for model_name, paths in mc_results.items():
-            if 'variance' in model_name:
-                continue
-            
-            n_paths, n_days = paths.shape
-            x_days = list(range(n_days))
-            
-            # Sample paths (show 50 for clarity)
-            sample_indices = np.random.choice(n_paths, min(50, n_paths), replace=False)
-            for idx in sample_indices:
-                fig.add_trace(go.Scatter(
-                    x=x_days,
-                    y=paths[idx],
-                    mode='lines',
-                    line=dict(color=model_colors.get(model_name, 'gray'), width=0.5),
-                    opacity=0.15,
-                    showlegend=False,
-                    hoverinfo='skip'
-                ))
-            
-            # Mean path
-            mean_path = np.mean(paths, axis=0)
-            fig.add_trace(go.Scatter(
-                x=x_days,
-                y=mean_path,
-                name=f'{model_name.upper()} Mean',
-                line=dict(color=model_colors.get(model_name, 'gray'), width=3),
-                hovertemplate=f'{model_name.upper()}<br>Day: %{{x}}<br>Price: $%{{y:.2f}}<extra></extra>'
-            ))
-            
-            # Confidence bands (95%)
-            percentile_5 = np.percentile(paths, 5, axis=0)
-            percentile_95 = np.percentile(paths, 95, axis=0)
-            
-            fig.add_trace(go.Scatter(
-                x=x_days + x_days[::-1],
-                y=percentile_95.tolist() + percentile_5.tolist()[::-1],
-                fill='toself',
-                fillcolor=f'rgba{tuple(list(int(model_colors.get(model_name, "#000000")[i:i+2], 16) for i in (1, 3, 5)) + [0.1])}',
-                line=dict(color='rgba(255,255,255,0)'),
-                name=f'{model_name.upper()} 95% CI',
-                showlegend=True,
-                hoverinfo='skip'
-            ))
-        
-        # Current price line
-        fig.add_hline(
-            y=current_price,
-            line_dash="dash",
-            line_color="black",
-            annotation_text=f"Current: ${current_price:.2f}",
-            annotation_position="right"
-        )
-        
-        fig.update_layout(
-            title='Monte Carlo Price Simulations (4 Models, 10,000 Paths Each)',
-            xaxis_title='Days Forward',
-            yaxis_title='Price ($)',
-            height=700,
-            template='plotly_white',
-            hovermode='x unified',
-            legend=dict(x=0.01, y=0.99, bgcolor='rgba(255,255,255,0.8)')
-        )
-        
-        return fig
-    
-    def create_buy_signals_frequency_chart(
-        self,
-        buy_signals: List[Dict],
-        spectral_results: Dict,
-        dates: pd.DatetimeIndex
-    ) -> go.Figure:
-        """
-        Chart 6: Buy signals mapped to frequency domain
-        """
-        if not buy_signals:
-            # Return empty figure with message
-            fig = go.Figure()
-            fig.add_annotation(
-                text="No buy signals detected in this period",
-                xref="paper", yref="paper",
-                x=0.5, y=0.5, showarrow=False,
-                font=dict(size=20, color="gray")
-            )
-            fig.update_layout(height=400, template='plotly_white')
-            return fig
-        
-        fig = make_subplots(
-            rows=2, cols=1,
-            subplot_titles=['Buy Signals in Time Domain', 'Buy Signal Frequency Distribution'],
-            vertical_spacing=0.15,
-            specs=[[{'type': 'scatter'}], [{'type': 'bar'}]]
-        )
-        
-        # Time domain signals
-        signal_dates = [pd.to_datetime(s['date']) for s in buy_signals]
-        signal_prices = [s['price'] for s in buy_signals]
-        signal_momentum = [s['momentum'] for s in buy_signals]
-        
-        fig.add_trace(go.Scatter(
-            x=signal_dates,
-            y=signal_prices,
-            mode='markers',
-            marker=dict(
-                size=[abs(m)*30 for m in signal_momentum],
-                color=signal_momentum,
-                colorscale='RdYlGn',
-                showscale=True,
-                colorbar=dict(title="Momentum", x=1.1),
-                line=dict(color='black', width=1)
-            ),
-            name='Buy Signals',
-            hovertemplate='Date: %{x}<br>Price: $%{y:.2f}<br>Momentum: %{marker.color:.3f}<extra></extra>'
-        ), row=1, col=1)
-        
-        # Frequency distribution of signals (by month/week)
-        signal_series = pd.Series(1, index=signal_dates)
-        signal_freq = signal_series.resample('W').sum()
-        
-        fig.add_trace(go.Bar(
-            x=signal_freq.index,
-            y=signal_freq.values,
-            name='Signals per Week',
-            marker=dict(color='#00AA44'),
-            hovertemplate='Week: %{x}<br>Signals: %{y}<extra></extra>'
-        ), row=2, col=1)
-        
-        fig.update_xaxes(title_text='Date', row=1, col=1)
-        fig.update_yaxes(title_text='Price ($)', row=1, col=1)
-        fig.update_xaxes(title_text='Week', row=2, col=1)
-        fig.update_yaxes(title_text='Number of Signals', row=2, col=1)
-        
-        fig.update_layout(
-            height=800,
-            title_text='Buy Signal Analysis - Frequency Domain Mapping',
-            template='plotly_white',
-            showlegend=False
-        )
-        
-        return fig
-    
-    def create_comprehensive_dashboard(
-        self,
-        dates: pd.DatetimeIndex,
-        original_prices: np.ndarray,
-        spectral_results: Dict,
-        momentum_signals: Dict,
-        mc_results: Dict,
-        buy_signals: List[Dict],
-        current_price: float
-    ) -> Dict[str, go.Figure]:
-        """
-        Create all charts and return as dictionary
-        """
-        charts = {}
-        
-        # Chart 1: Price decomposition with anti-aliasing
-        charts['price_decomposition'] = self.create_price_decomposition_chart(
-            dates, original_prices, spectral_results, buy_signals
-        )
-        
-        # Chart 2: Frequency spectrum
-        charts['frequency_spectrum'] = self.create_frequency_spectrum_chart(spectral_results)
-        
-        # Chart 3: Phase angles
-        charts['phase_angles'] = self.create_phase_angle_chart(spectral_results, dates)
-        
-        # Chart 4: Momentum signals
-        charts['momentum_signals'] = self.create_momentum_signals_chart(
-            dates, momentum_signals, buy_signals
-        )
-        
-        # Chart 5: Monte Carlo
-        charts['monte_carlo'] = self.create_monte_carlo_chart(mc_results, current_price)
-        
-        # Chart 6: Buy signals in frequency domain
-        charts['buy_signals_freq'] = self.create_buy_signals_frequency_chart(
-            buy_signals, spectral_results, dates
-        )
-        
-        self.figures = charts
-        return charts
-    
-    def export_to_html(self, charts: Dict[str, go.Figure], filename: str):
-        """Export all charts to a single HTML file"""
-        with open(filename, 'w', encoding='utf-8') as f:
-            f.write("""
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="utf-8">
-    <title>Quantitative Finance Analysis Report</title>
-    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
-    <style>
-        body { font-family: Arial, sans-serif; margin: 20px; background: #f5f5f5; }
-        .chart-container { background: white; margin: 20px 0; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
-        h1 { color: #333; text-align: center; }
-        h2 { color: #666; border-bottom: 2px solid #0066CC; padding-bottom: 10px; }
-    </style>
-</head>
-<body>
-    <h1>📊 Professional Quantitative Finance Analysis Report</h1>
-""")
-            
-            for chart_name, fig in charts.items():
-                title = chart_name.replace('_', ' ').title()
-                f.write(f'<div class="chart-container"><h2>{title}</h2>')
-                f.write(fig.to_html(include_plotlyjs=False, div_id=chart_name))
-                f.write('</div>')
-            
-            f.write("""
-</body>
-</html>
-""")
-    
-    def export_to_image(self, fig: go.Figure, filename: str, format: str = 'png'):
-        """Export figure to static image"""
-        try:
-            fig.write_image(filename, format=format, width=1400, height=800, scale=2)
-        except Exception as e:
-            print(f"Warning: Could not export image: {e}")
-            print("Install kaleido for image export: pip install kaleido")