increase prediction horizon

web/clean_dashboard.py

@@ -80,6 +80,9 @@ except ImportError:
 # Import RL COB trader for 1B parameter model integration
 from core.realtime_rl_cob_trader import RealtimeRLCOBTrader, PredictionResult
 
+# Import multi-timeframe prediction system
+from NN.models.multi_timeframe_predictor import MultiTimeframePredictor, PredictionHorizon
+
 # Single unified orchestrator with full ML capabilities
 
 class CleanTradingDashboard:
@@ -110,6 +113,10 @@ class CleanTradingDashboard:
         # Initialize enhanced training system for predictions
         self.training_system = None
         self._initialize_enhanced_training_system()
+
+        # Initialize multi-timeframe prediction system
+        self.multi_timeframe_predictor = None
+        self._initialize_multi_timeframe_predictor()
         
         # Initialize layout and component managers
         self.layout_manager = DashboardLayoutManager(
@@ -5101,7 +5108,31 @@ class CleanTradingDashboard:
         except Exception as e:
             logger.debug(f"Error getting trade outcome: {e}")
             return None
-    
+
+    def export_trade_history_csv(self, filename: Optional[str] = None) -> str:
+        """Export complete trade history to CSV file for analysis"""
+        try:
+            if self.trading_executor and hasattr(self.trading_executor, 'export_trades_to_csv'):
+                filepath = self.trading_executor.export_trades_to_csv(filename)
+
+                if filepath:
+                    print(f"📊 Trade history exported successfully!")
+                    print(f"📁 File location: {filepath}")
+                    print("📈 Analysis summary saved alongside CSV file")
+                return filepath
+            else:
+                logger.warning("Trading executor not available or CSV export not supported")
+                return ""
+        except Exception as e:
+            logger.error(f"Error exporting trade history: {e}")
+            return ""
+
+    def export_trades_now(self) -> str:
+        """Convenience method to export trades immediately with timestamp"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"trades_export_{timestamp}.csv"
+        return self.export_trade_history_csv(filename)
+
     def _train_dqn_on_signal(self, signal: Dict, trade_outcome: Dict):
         """Train DQN agent on executed signal with trade outcome"""
         try:
@@ -6279,6 +6310,20 @@ class CleanTradingDashboard:
             logger.error(f"Error initializing enhanced training system: {e}")
             self.training_system = None
 
+    def _initialize_multi_timeframe_predictor(self):
+        """Initialize multi-timeframe prediction system"""
+        try:
+            if self.orchestrator:
+                self.multi_timeframe_predictor = MultiTimeframePredictor(self.orchestrator)
+                logger.info("Multi-timeframe prediction system initialized")
+            else:
+                logger.warning("Cannot initialize multi-timeframe predictor - no orchestrator available")
+                self.multi_timeframe_predictor = None
+
+        except Exception as e:
+            logger.error(f"Error initializing multi-timeframe predictor: {e}")
+            self.multi_timeframe_predictor = None
+
     def _initialize_cob_integration(self):
         """Initialize COB integration using orchestrator's COB system"""
         try:
@@ -6597,13 +6642,71 @@ class CleanTradingDashboard:
                     self.recent_decisions.pop(0)
                 
                 logger.info(f"COB SIGNAL: {symbol} {signal['action']} signal generated - imbalance: {imbalance:.3f}, confidence: {signal['confidence']:.3f}")
-                
+
+                # Enhance signal with multi-timeframe predictions if available
+                enhanced_signal = self._enhance_signal_with_multi_timeframe(signal)
+                if enhanced_signal:
+                    signal = enhanced_signal
+
                 # Process the signal for potential execution
                 self._process_dashboard_signal(signal)
                 
         except Exception as e:
             logger.debug(f"Error generating COB signal for {symbol}: {e}")
-    
+
+    def _enhance_signal_with_multi_timeframe(self, signal: Dict) -> Optional[Dict]:
+        """Enhance signal with multi-timeframe predictions for better accuracy and hold times"""
+        try:
+            if not self.multi_timeframe_predictor:
+                return signal
+
+            symbol = signal.get('symbol', 'ETH/USDT')
+
+            # Generate multi-timeframe prediction
+            multi_prediction = self.multi_timeframe_predictor.generate_multi_timeframe_prediction(symbol)
+
+            if not multi_prediction:
+                return signal
+
+            # Check if we should execute the trade
+            should_execute, reason = self.multi_timeframe_predictor.should_execute_trade(multi_prediction)
+
+            if not should_execute:
+                logger.debug(f"Multi-timeframe analysis: Not executing - {reason}")
+                return None  # Don't execute this signal
+
+            # Find the best prediction for enhanced signal
+            best_prediction = None
+            best_confidence = 0
+
+            for horizon, pred in multi_prediction.predictions.items():
+                if pred['confidence'] > best_confidence:
+                    best_confidence = pred['confidence']
+                    best_prediction = (horizon, pred)
+
+            if best_prediction:
+                horizon, pred = best_prediction
+
+                # Enhance original signal with multi-timeframe data
+                enhanced_signal = signal.copy()
+                enhanced_signal['confidence'] = pred['confidence']  # Use higher confidence
+                enhanced_signal['prediction_horizon'] = horizon.value  # Store horizon
+                enhanced_signal['hold_time_minutes'] = horizon.value  # Suggested hold time
+                enhanced_signal['multi_timeframe'] = True
+                enhanced_signal['models_used'] = pred.get('models_used', 1)
+                enhanced_signal['reasoning'] = f"{signal.get('reasoning', '')} | Multi-timeframe {horizon.value}min prediction"
+
+                logger.info(f"Enhanced signal: {symbol} {pred['action']} with {pred['confidence']:.2f} confidence "
+                           f"for {horizon.value}-minute horizon")
+
+                return enhanced_signal
+
+            return signal
+
+        except Exception as e:
+            logger.error(f"Error enhancing signal with multi-timeframe: {e}")
+            return signal
+
     def _feed_cob_data_to_models(self, symbol: str, cob_snapshot: dict):
         """Feed COB data to ALL models for training and inference - Enhanced integration"""
         try: