cleanup and reorgnization
This commit is contained in:
Dobromir Popov
@ -30,7 +30,7 @@ import logging
|
||||
import json
|
||||
import time
|
||||
import threading
|
||||
from typing import Dict, List, Optional, Any
|
||||
from typing import Dict, List, Optional, Any, Union
|
||||
import os
|
||||
import asyncio
|
||||
import dash_bootstrap_components as dbc
|
||||
@ -51,20 +51,15 @@ logging.getLogger('dash.dash').setLevel(logging.WARNING)
|
||||
# Import core components
|
||||
from core.config import get_config
|
||||
from core.data_provider import DataProvider
|
||||
from core.enhanced_orchestrator import EnhancedTradingOrchestrator
|
||||
from core.orchestrator import TradingOrchestrator
|
||||
from core.trading_executor import TradingExecutor
|
||||
|
||||
# Import layout and component managers
|
||||
from web.layout_manager import DashboardLayoutManager
|
||||
from web.component_manager import DashboardComponentManager
|
||||
|
||||
# Import optional components
|
||||
try:
|
||||
from core.enhanced_orchestrator import EnhancedTradingOrchestrator
|
||||
ENHANCED_RL_AVAILABLE = True
|
||||
except ImportError:
|
||||
ENHANCED_RL_AVAILABLE = False
|
||||
logger.warning("Enhanced RL components not available")
|
||||
# Enhanced RL components are no longer available - using Basic orchestrator only
|
||||
ENHANCED_RL_AVAILABLE = False
|
||||
|
||||
try:
|
||||
from core.cob_integration import COBIntegration
|
||||
@ -86,23 +81,24 @@ except ImportError:
|
||||
# Import RL COB trader for 1B parameter model integration
|
||||
from core.realtime_rl_cob_trader import RealtimeRLCOBTrader, PredictionResult
|
||||
|
||||
# Using Basic orchestrator only - Enhanced orchestrator removed for stability
|
||||
ENHANCED_ORCHESTRATOR_AVAILABLE = False
|
||||
USE_ENHANCED_ORCHESTRATOR = False
|
||||
|
||||
class CleanTradingDashboard:
|
||||
"""Clean, modular trading dashboard implementation"""
|
||||
|
||||
def __init__(self, data_provider: DataProvider = None, orchestrator: EnhancedTradingOrchestrator = None, trading_executor: TradingExecutor = None):
|
||||
def __init__(self, data_provider: Optional[DataProvider] = None, orchestrator: Optional[Any] = None, trading_executor: Optional[TradingExecutor] = None):
|
||||
self.config = get_config()
|
||||
|
||||
# Initialize components
|
||||
self.data_provider = data_provider or DataProvider()
|
||||
self.trading_executor = trading_executor or TradingExecutor()
|
||||
|
||||
# Initialize orchestrator with enhanced capabilities
|
||||
# Initialize orchestrator - USING BASIC ORCHESTRATOR ONLY
|
||||
if orchestrator is None:
|
||||
self.orchestrator = EnhancedTradingOrchestrator(
|
||||
data_provider=self.data_provider,
|
||||
symbols=['ETH/USDT', 'BTC/USDT'],
|
||||
enhanced_rl_training=True
|
||||
)
|
||||
self.orchestrator = TradingOrchestrator(self.data_provider)
|
||||
logger.info("Using Basic Trading Orchestrator for stability")
|
||||
else:
|
||||
self.orchestrator = orchestrator
|
||||
|
||||
@ -141,11 +137,12 @@ class CleanTradingDashboard:
|
||||
self.is_streaming = False
|
||||
self.tick_cache = []
|
||||
|
||||
# COB data cache
|
||||
# COB data cache - using same approach as cob_realtime_dashboard.py
|
||||
self.cob_cache = {
|
||||
'ETH/USDT': {'last_update': 0, 'data': None, 'updates_count': 0},
|
||||
'BTC/USDT': {'last_update': 0, 'data': None, 'updates_count': 0}
|
||||
}
|
||||
self.latest_cob_data = {} # Cache for COB integration data
|
||||
|
||||
# Initialize timezone
|
||||
timezone_name = self.config.get('system', {}).get('timezone', 'Europe/Sofia')
|
||||
@ -170,8 +167,8 @@ class CleanTradingDashboard:
|
||||
# Connect to orchestrator for real trading signals
|
||||
self._connect_to_orchestrator()
|
||||
|
||||
# Initialize REAL COB integration from enhanced orchestrator (NO separate RL trader needed)
|
||||
self._initialize_cob_integration()
|
||||
# Initialize REAL COB integration - using proper approach from enhanced orchestrator
|
||||
self._initialize_cob_integration_proper()
|
||||
|
||||
# Start Universal Data Stream
|
||||
if self.unified_stream:
|
||||
@ -182,40 +179,28 @@ class CleanTradingDashboard:
|
||||
# Start signal generation loop to ensure continuous trading signals
|
||||
self._start_signal_generation_loop()
|
||||
|
||||
logger.info("Clean Trading Dashboard initialized with REAL COB integration and signal generation")
|
||||
logger.info("Clean Trading Dashboard initialized with PROPER COB integration and signal generation")
|
||||
|
||||
def load_model_dynamically(self, model_name: str, model_type: str, model_path: str = None) -> bool:
|
||||
"""Dynamically load a model at runtime"""
|
||||
try:
|
||||
if hasattr(self.orchestrator, 'load_model'):
|
||||
success = self.orchestrator.load_model(model_name, model_type, model_path)
|
||||
if success:
|
||||
logger.info(f"Successfully loaded model: {model_name}")
|
||||
return True
|
||||
return False
|
||||
except Exception as e:
|
||||
logger.error(f"Error loading model {model_name}: {e}")
|
||||
return False
|
||||
def load_model_dynamically(self, model_name: str, model_type: str, model_path: Optional[str] = None) -> bool:
|
||||
"""Dynamically load a model at runtime - Not implemented in orchestrator"""
|
||||
logger.warning("Dynamic model loading not implemented in orchestrator")
|
||||
return False
|
||||
|
||||
def unload_model_dynamically(self, model_name: str) -> bool:
|
||||
"""Dynamically unload a model at runtime"""
|
||||
try:
|
||||
if hasattr(self.orchestrator, 'unload_model'):
|
||||
success = self.orchestrator.unload_model(model_name)
|
||||
if success:
|
||||
logger.info(f"Successfully unloaded model: {model_name}")
|
||||
return True
|
||||
return False
|
||||
except Exception as e:
|
||||
logger.error(f"Error unloading model {model_name}: {e}")
|
||||
return False
|
||||
"""Dynamically unload a model at runtime - Not implemented in orchestrator"""
|
||||
logger.warning("Dynamic model unloading not implemented in orchestrator")
|
||||
return False
|
||||
|
||||
def get_loaded_models_status(self) -> Dict[str, Any]:
|
||||
"""Get status of all loaded models"""
|
||||
"""Get status of all loaded models from training metrics"""
|
||||
try:
|
||||
if hasattr(self.orchestrator, 'list_loaded_models'):
|
||||
return self.orchestrator.list_loaded_models()
|
||||
return {'loaded_models': {}, 'total_models': 0, 'system_status': 'NO_ORCHESTRATOR'}
|
||||
# Get status from training metrics instead
|
||||
metrics = self._get_training_metrics()
|
||||
return {
|
||||
'loaded_models': metrics.get('loaded_models', {}),
|
||||
'total_models': len(metrics.get('loaded_models', {})),
|
||||
'system_status': 'ACTIVE' if metrics.get('training_status', {}).get('active_sessions', 0) > 0 else 'INACTIVE'
|
||||
}
|
||||
except Exception as e:
|
||||
logger.error(f"Error getting model status: {e}")
|
||||
return {'loaded_models': {}, 'total_models': 0, 'system_status': 'ERROR'}
|
||||
@ -1022,112 +1007,144 @@ class CleanTradingDashboard:
|
||||
return None
|
||||
|
||||
def _get_cob_status(self) -> Dict:
|
||||
"""Get REAL COB integration status - NO SIMULATION"""
|
||||
"""Get REAL COB integration status - FIXED TO USE ENHANCED ORCHESTRATOR PROPERLY"""
|
||||
try:
|
||||
status = {
|
||||
'trading_enabled': bool(self.trading_executor and getattr(self.trading_executor, 'trading_enabled', False)),
|
||||
'simulation_mode': bool(self.trading_executor and getattr(self.trading_executor, 'simulation_mode', True)),
|
||||
'data_provider_status': 'Active',
|
||||
'websocket_status': 'Connected' if self.is_streaming else 'Disconnected',
|
||||
'cob_status': 'No Real COB Integration', # Default
|
||||
'cob_status': 'No COB Integration', # Default
|
||||
'orchestrator_type': 'Basic',
|
||||
'rl_model_status': 'Inactive',
|
||||
'predictions_count': 0,
|
||||
'cache_size': 0
|
||||
}
|
||||
|
||||
# Check REAL COB integration from enhanced orchestrator
|
||||
if hasattr(self.orchestrator, 'cob_integration') and self.orchestrator.cob_integration:
|
||||
cob_integration = self.orchestrator.cob_integration
|
||||
# Check if we have Enhanced Orchestrator - PROPER TYPE CHECK
|
||||
is_enhanced = (ENHANCED_ORCHESTRATOR_AVAILABLE and
|
||||
self.orchestrator.__class__.__name__ == 'EnhancedTradingOrchestrator')
|
||||
|
||||
if is_enhanced:
|
||||
status['orchestrator_type'] = 'Enhanced'
|
||||
|
||||
# Get real COB integration statistics
|
||||
try:
|
||||
cob_stats = cob_integration.get_statistics()
|
||||
if cob_stats:
|
||||
active_symbols = cob_stats.get('active_symbols', [])
|
||||
total_updates = cob_stats.get('total_updates', 0)
|
||||
provider_status = cob_stats.get('provider_status', 'Unknown')
|
||||
|
||||
if active_symbols:
|
||||
status['cob_status'] = f'REAL COB Active ({len(active_symbols)} symbols)'
|
||||
status['active_symbols'] = active_symbols
|
||||
status['cache_size'] = total_updates
|
||||
status['provider_status'] = provider_status
|
||||
# Check COB integration in Enhanced orchestrator
|
||||
if hasattr(self.orchestrator, 'cob_integration'):
|
||||
cob_integration = getattr(self.orchestrator, 'cob_integration', None)
|
||||
if cob_integration is not None:
|
||||
# Get real COB integration statistics
|
||||
try:
|
||||
if hasattr(cob_integration, 'get_statistics'):
|
||||
cob_stats = cob_integration.get_statistics()
|
||||
if cob_stats:
|
||||
active_symbols = cob_stats.get('active_symbols', [])
|
||||
total_updates = cob_stats.get('total_updates', 0)
|
||||
provider_status = cob_stats.get('provider_status', 'Unknown')
|
||||
|
||||
if active_symbols:
|
||||
status['cob_status'] = f'Enhanced COB Active ({len(active_symbols)} symbols)'
|
||||
status['active_symbols'] = active_symbols
|
||||
status['cache_size'] = total_updates
|
||||
status['provider_status'] = provider_status
|
||||
else:
|
||||
status['cob_status'] = 'Enhanced COB Integration Loaded (No Data)'
|
||||
else:
|
||||
status['cob_status'] = 'Enhanced COB Integration (Stats Unavailable)'
|
||||
else:
|
||||
status['cob_status'] = 'Enhanced COB Integration (No Stats Method)'
|
||||
|
||||
except Exception as e:
|
||||
logger.debug(f"Error getting COB statistics: {e}")
|
||||
status['cob_status'] = 'Enhanced COB Integration (Error Getting Stats)'
|
||||
else:
|
||||
status['cob_status'] = 'REAL COB Integration Loaded (No Data)'
|
||||
status['cob_status'] = 'Enhanced Orchestrator (COB Integration Not Initialized)'
|
||||
# Don't log warning here to avoid spam, just info level
|
||||
logger.debug("Enhanced orchestrator has COB integration attribute but it's None")
|
||||
else:
|
||||
status['cob_status'] = 'REAL COB Integration (Stats Unavailable)'
|
||||
|
||||
except Exception as e:
|
||||
logger.debug(f"Error getting COB statistics: {e}")
|
||||
status['cob_status'] = 'REAL COB Integration (Error Getting Stats)'
|
||||
status['cob_status'] = 'Enhanced Orchestrator Missing COB Integration'
|
||||
logger.debug("Enhanced orchestrator available but has no COB integration attribute")
|
||||
else:
|
||||
status['cob_status'] = 'Enhanced Orchestrator Missing COB Integration'
|
||||
logger.debug("Enhanced orchestrator available but has no COB integration attribute")
|
||||
else:
|
||||
status['cob_status'] = 'No Enhanced Orchestrator COB Integration'
|
||||
logger.warning("Enhanced orchestrator has no COB integration - using basic orchestrator")
|
||||
if not ENHANCED_ORCHESTRATOR_AVAILABLE:
|
||||
status['cob_status'] = 'Enhanced Orchestrator Not Available'
|
||||
status['orchestrator_type'] = 'Basic (Enhanced Unavailable)'
|
||||
else:
|
||||
status['cob_status'] = 'Basic Orchestrator (No COB Support)'
|
||||
status['orchestrator_type'] = 'Basic (Enhanced Not Used)'
|
||||
|
||||
return status
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error getting COB status: {e}")
|
||||
return {'error': str(e), 'cob_status': 'Error Getting Status'}
|
||||
return {'error': str(e), 'cob_status': 'Error Getting Status', 'orchestrator_type': 'Unknown'}
|
||||
|
||||
def _get_cob_snapshot(self, symbol: str) -> Optional[Any]:
|
||||
"""Get COB snapshot for symbol - REAL DATA ONLY"""
|
||||
"""Get COB snapshot for symbol using enhanced orchestrator approach"""
|
||||
try:
|
||||
# Get from REAL COB integration via enhanced orchestrator
|
||||
if not hasattr(self.orchestrator, 'cob_integration') or self.orchestrator.cob_integration is None:
|
||||
logger.warning(f"No REAL COB integration available for {symbol}")
|
||||
return None
|
||||
|
||||
cob_integration = self.orchestrator.cob_integration
|
||||
|
||||
# Get real COB snapshot
|
||||
if hasattr(cob_integration, 'get_cob_snapshot'):
|
||||
snapshot = cob_integration.get_cob_snapshot(symbol)
|
||||
if snapshot:
|
||||
logger.debug(f"Retrieved REAL COB snapshot for {symbol}")
|
||||
return snapshot
|
||||
else:
|
||||
logger.debug(f"No REAL COB data available for {symbol}")
|
||||
# Get from Enhanced Orchestrator's COB integration (proper way)
|
||||
if (ENHANCED_ORCHESTRATOR_AVAILABLE and
|
||||
hasattr(self.orchestrator, 'cob_integration') and
|
||||
self.orchestrator.__class__.__name__ == 'EnhancedTradingOrchestrator'):
|
||||
|
||||
cob_integration = getattr(self.orchestrator, 'cob_integration', None)
|
||||
if cob_integration is not None:
|
||||
# Get real COB snapshot using the proper method
|
||||
if hasattr(cob_integration, 'get_cob_snapshot'):
|
||||
snapshot = cob_integration.get_cob_snapshot(symbol)
|
||||
if snapshot:
|
||||
logger.debug(f"Retrieved Enhanced COB snapshot for {symbol}")
|
||||
return snapshot
|
||||
else:
|
||||
logger.debug(f"No Enhanced COB data available for {symbol}")
|
||||
elif hasattr(cob_integration, 'get_consolidated_orderbook'):
|
||||
# Alternative method name
|
||||
snapshot = cob_integration.get_consolidated_orderbook(symbol)
|
||||
if snapshot:
|
||||
logger.debug(f"Retrieved Enhanced COB orderbook for {symbol}")
|
||||
return snapshot
|
||||
else:
|
||||
logger.warning("Enhanced COB integration has no recognized snapshot method")
|
||||
else:
|
||||
logger.warning("COB integration has no get_cob_snapshot method")
|
||||
logger.debug(f"No Enhanced COB integration available for {symbol}")
|
||||
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Error getting REAL COB snapshot for {symbol}: {e}")
|
||||
logger.warning(f"Error getting Enhanced COB snapshot for {symbol}: {e}")
|
||||
return None
|
||||
|
||||
def _get_training_metrics(self) -> Dict:
|
||||
"""Get training metrics data - Enhanced with loaded models and real-time losses"""
|
||||
"""Get training metrics data - HANDLES BOTH ENHANCED AND BASIC ORCHESTRATORS"""
|
||||
try:
|
||||
metrics = {}
|
||||
|
||||
# Loaded Models Section - FIXED
|
||||
loaded_models = {}
|
||||
|
||||
# 1. DQN Model Status and Loss Tracking
|
||||
# 1. DQN Model Status and Loss Tracking - FIXED ATTRIBUTE ACCESS
|
||||
dqn_active = False
|
||||
dqn_last_loss = 0.0
|
||||
dqn_prediction_count = 0
|
||||
last_action = 'NONE'
|
||||
last_confidence = 0.0
|
||||
|
||||
if self.orchestrator and hasattr(self.orchestrator, 'sensitivity_dqn_agent'):
|
||||
if self.orchestrator.sensitivity_dqn_agent is not None:
|
||||
# Using Basic orchestrator only - Enhanced orchestrator removed
|
||||
is_enhanced = False
|
||||
|
||||
# Basic orchestrator doesn't have DQN agent - create default status
|
||||
try:
|
||||
# Check if Basic orchestrator has any DQN features
|
||||
if hasattr(self.orchestrator, 'some_basic_dqn_method'):
|
||||
dqn_active = True
|
||||
dqn_agent = self.orchestrator.sensitivity_dqn_agent
|
||||
|
||||
# Get DQN stats
|
||||
if hasattr(dqn_agent, 'get_enhanced_training_stats'):
|
||||
dqn_stats = dqn_agent.get_enhanced_training_stats()
|
||||
dqn_last_loss = dqn_stats.get('last_loss', 0.0)
|
||||
dqn_prediction_count = dqn_stats.get('prediction_count', 0)
|
||||
|
||||
# Get last action with confidence
|
||||
if hasattr(dqn_agent, 'last_action_taken') and dqn_agent.last_action_taken is not None:
|
||||
action_map = {0: 'SELL', 1: 'BUY'}
|
||||
last_action = action_map.get(dqn_agent.last_action_taken, 'NONE')
|
||||
last_confidence = getattr(dqn_agent, 'last_confidence', 0.0) * 100
|
||||
# Get basic stats if available
|
||||
else:
|
||||
dqn_active = False
|
||||
logger.debug("Basic orchestrator - no DQN features available")
|
||||
except Exception as e:
|
||||
logger.debug(f"Error checking Basic orchestrator DQN: {e}")
|
||||
dqn_active = False
|
||||
|
||||
dqn_model_info = {
|
||||
'active': dqn_active,
|
||||
@ -1139,72 +1156,46 @@ class CleanTradingDashboard:
|
||||
},
|
||||
'loss_5ma': dqn_last_loss, # Real loss from training
|
||||
'model_type': 'DQN',
|
||||
'description': 'Deep Q-Network Agent',
|
||||
'description': 'Deep Q-Network Agent' + (' (Enhanced)' if is_enhanced else ' (Basic)'),
|
||||
'prediction_count': dqn_prediction_count,
|
||||
'epsilon': getattr(self.orchestrator.sensitivity_dqn_agent, 'epsilon', 0.0) if dqn_active else 1.0
|
||||
'epsilon': 1.0 # Default epsilon for Basic orchestrator
|
||||
}
|
||||
loaded_models['dqn'] = dqn_model_info
|
||||
|
||||
# 2. CNN Model Status
|
||||
# 2. CNN Model Status - NOT AVAILABLE IN BASIC ORCHESTRATOR
|
||||
cnn_active = False
|
||||
cnn_last_loss = 0.0
|
||||
|
||||
if hasattr(self.orchestrator, 'williams_structure') and self.orchestrator.williams_structure:
|
||||
cnn_active = True
|
||||
williams = self.orchestrator.williams_structure
|
||||
if hasattr(williams, 'get_training_stats'):
|
||||
cnn_stats = williams.get_training_stats()
|
||||
cnn_last_loss = cnn_stats.get('avg_loss', 0.0234)
|
||||
cnn_last_loss = 0.0234 # Default loss value
|
||||
|
||||
cnn_model_info = {
|
||||
'active': cnn_active,
|
||||
'parameters': 50000000, # ~50M params
|
||||
'last_prediction': {
|
||||
'timestamp': datetime.now().strftime('%H:%M:%S'),
|
||||
'action': 'MONITORING',
|
||||
'action': 'MONITORING' if cnn_active else 'INACTIVE',
|
||||
'confidence': 0.0
|
||||
},
|
||||
'loss_5ma': cnn_last_loss,
|
||||
'model_type': 'CNN',
|
||||
'description': 'Williams Market Structure CNN'
|
||||
'description': 'Williams Market Structure CNN' + (' (Enhanced Only)' if not is_enhanced else '')
|
||||
}
|
||||
loaded_models['cnn'] = cnn_model_info
|
||||
|
||||
# 3. COB RL Model Status - Use REAL COB integration from enhanced orchestrator
|
||||
# 3. COB RL Model Status - NOT AVAILABLE IN BASIC ORCHESTRATOR
|
||||
cob_active = False
|
||||
cob_last_loss = 0.0
|
||||
cob_last_loss = 0.012 # Default loss value
|
||||
cob_predictions_count = 0
|
||||
|
||||
# Check for REAL COB integration in enhanced orchestrator
|
||||
if hasattr(self.orchestrator, 'cob_integration') and self.orchestrator.cob_integration:
|
||||
cob_active = True
|
||||
try:
|
||||
# Get COB integration statistics
|
||||
cob_stats = self.orchestrator.cob_integration.get_statistics()
|
||||
if cob_stats:
|
||||
cob_predictions_count = cob_stats.get('total_predictions', 0)
|
||||
provider_stats = cob_stats.get('provider_stats', {})
|
||||
cob_last_loss = provider_stats.get('avg_training_loss', 0.012)
|
||||
|
||||
# Get latest COB features count
|
||||
total_cob_features = len(getattr(self.orchestrator, 'latest_cob_features', {}))
|
||||
if total_cob_features > 0:
|
||||
cob_predictions_count += total_cob_features * 100 # Estimate
|
||||
|
||||
except Exception as e:
|
||||
logger.debug(f"Could not get REAL COB stats: {e}")
|
||||
|
||||
cob_model_info = {
|
||||
'active': cob_active,
|
||||
'parameters': 400000000, # 400M optimized (real COB integration)
|
||||
'parameters': 400000000, # 400M optimized (Enhanced COB integration)
|
||||
'last_prediction': {
|
||||
'timestamp': datetime.now().strftime('%H:%M:%S'),
|
||||
'action': 'REAL_COB_INFERENCE' if cob_active else 'INACTIVE',
|
||||
'action': 'ENHANCED_COB_INFERENCE' if cob_active else ('INACTIVE' if is_enhanced else 'NOT_AVAILABLE'),
|
||||
'confidence': 0.0
|
||||
},
|
||||
'loss_5ma': cob_last_loss,
|
||||
'model_type': 'REAL_COB_RL',
|
||||
'description': 'Real COB Integration from Enhanced Orchestrator',
|
||||
'model_type': 'ENHANCED_COB_RL',
|
||||
'description': 'Enhanced COB Integration' + (' (Enhanced Only)' if not is_enhanced else ''),
|
||||
'predictions_count': cob_predictions_count
|
||||
}
|
||||
loaded_models['cob_rl'] = cob_model_info
|
||||
@ -1220,7 +1211,8 @@ class CleanTradingDashboard:
|
||||
'signal_generation': 'ACTIVE' if signal_generation_active else 'INACTIVE',
|
||||
'last_update': datetime.now().strftime('%H:%M:%S'),
|
||||
'models_loaded': len(loaded_models),
|
||||
'total_parameters': sum(m['parameters'] for m in loaded_models.values() if m['active'])
|
||||
'total_parameters': sum(m['parameters'] for m in loaded_models.values() if m['active']),
|
||||
'orchestrator_type': 'Enhanced' if is_enhanced else 'Basic'
|
||||
}
|
||||
|
||||
# COB $1 Buckets (sample data for now)
|
||||
@ -1229,7 +1221,7 @@ class CleanTradingDashboard:
|
||||
return metrics
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error getting enhanced training metrics: {e}")
|
||||
logger.error(f"Error getting training metrics: {e}")
|
||||
return {'error': str(e), 'loaded_models': {}, 'training_status': {'active_sessions': 0}}
|
||||
|
||||
def _is_signal_generation_active(self) -> bool:
|
||||
@ -1275,13 +1267,8 @@ class CleanTradingDashboard:
|
||||
def signal_worker():
|
||||
logger.info("Starting continuous signal generation loop")
|
||||
|
||||
# Initialize DQN if not available
|
||||
if not hasattr(self.orchestrator, 'sensitivity_dqn_agent') or self.orchestrator.sensitivity_dqn_agent is None:
|
||||
try:
|
||||
self.orchestrator._initialize_sensitivity_dqn()
|
||||
logger.info("DQN Agent initialized for signal generation")
|
||||
except Exception as e:
|
||||
logger.warning(f"Could not initialize DQN: {e}")
|
||||
# Basic orchestrator doesn't have DQN - using momentum signals only
|
||||
logger.info("Using momentum-based signals (Basic orchestrator)")
|
||||
|
||||
while True:
|
||||
try:
|
||||
@ -1293,10 +1280,8 @@ class CleanTradingDashboard:
|
||||
if not current_price:
|
||||
continue
|
||||
|
||||
# 1. Generate DQN signal (with exploration)
|
||||
dqn_signal = self._generate_dqn_signal(symbol, current_price)
|
||||
if dqn_signal:
|
||||
self._process_dashboard_signal(dqn_signal)
|
||||
# 1. Generate basic signal (Basic orchestrator doesn't have DQN)
|
||||
# Skip DQN signals - Basic orchestrator doesn't support them
|
||||
|
||||
# 2. Generate simple momentum signal as backup
|
||||
momentum_signal = self._generate_momentum_signal(symbol, current_price)
|
||||
@ -1322,83 +1307,9 @@ class CleanTradingDashboard:
|
||||
logger.error(f"Error starting signal generation loop: {e}")
|
||||
|
||||
def _generate_dqn_signal(self, symbol: str, current_price: float) -> Optional[Dict]:
|
||||
"""Generate trading signal using DQN agent"""
|
||||
try:
|
||||
if not hasattr(self.orchestrator, 'sensitivity_dqn_agent') or self.orchestrator.sensitivity_dqn_agent is None:
|
||||
return None
|
||||
|
||||
dqn_agent = self.orchestrator.sensitivity_dqn_agent
|
||||
|
||||
# Create a simple state vector (expanded for DQN)
|
||||
state_features = []
|
||||
|
||||
# Get recent price data
|
||||
df = self.data_provider.get_historical_data(symbol, '1m', limit=20)
|
||||
if df is not None and len(df) >= 10:
|
||||
prices = df['close'].values
|
||||
volumes = df['volume'].values
|
||||
|
||||
# Price features
|
||||
state_features.extend([
|
||||
(current_price - prices[-2]) / prices[-2], # 1-period return
|
||||
(current_price - prices[-5]) / prices[-5], # 5-period return
|
||||
(current_price - prices[-10]) / prices[-10], # 10-period return
|
||||
prices.std() / prices.mean(), # Volatility
|
||||
volumes[-1] / volumes.mean(), # Volume ratio
|
||||
])
|
||||
|
||||
# Technical indicators
|
||||
sma_5 = prices[-5:].mean()
|
||||
sma_10 = prices[-10:].mean()
|
||||
state_features.extend([
|
||||
(current_price - sma_5) / sma_5, # Price vs SMA5
|
||||
(current_price - sma_10) / sma_10, # Price vs SMA10
|
||||
(sma_5 - sma_10) / sma_10, # SMA trend
|
||||
])
|
||||
else:
|
||||
# Fallback features if no data
|
||||
state_features = [0.0] * 8
|
||||
|
||||
# Pad or truncate to expected state size
|
||||
if hasattr(dqn_agent, 'state_dim'):
|
||||
target_size = dqn_agent.state_dim if isinstance(dqn_agent.state_dim, int) else dqn_agent.state_dim[0]
|
||||
while len(state_features) < target_size:
|
||||
state_features.append(0.0)
|
||||
state_features = state_features[:target_size]
|
||||
|
||||
state = np.array(state_features, dtype=np.float32)
|
||||
|
||||
# Get action from DQN (with exploration)
|
||||
action = dqn_agent.act(state, explore=True, current_price=current_price)
|
||||
|
||||
if action is not None:
|
||||
# Map action to signal
|
||||
action_map = {0: 'SELL', 1: 'BUY'}
|
||||
signal_action = action_map.get(action, 'HOLD')
|
||||
|
||||
# Calculate confidence based on epsilon (exploration factor)
|
||||
confidence = max(0.3, 1.0 - dqn_agent.epsilon)
|
||||
|
||||
# Store last action for display
|
||||
dqn_agent.last_action_taken = action
|
||||
dqn_agent.last_confidence = confidence
|
||||
|
||||
return {
|
||||
'action': signal_action,
|
||||
'symbol': symbol,
|
||||
'price': current_price,
|
||||
'confidence': confidence,
|
||||
'timestamp': datetime.now().strftime('%H:%M:%S'),
|
||||
'size': 0.01,
|
||||
'reason': f'DQN signal (ε={dqn_agent.epsilon:.3f})',
|
||||
'model': 'DQN'
|
||||
}
|
||||
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
logger.debug(f"Error generating DQN signal for {symbol}: {e}")
|
||||
return None
|
||||
"""Generate trading signal using DQN agent - NOT AVAILABLE IN BASIC ORCHESTRATOR"""
|
||||
# Basic orchestrator doesn't have DQN features
|
||||
return None
|
||||
|
||||
def _generate_momentum_signal(self, symbol: str, current_price: float) -> Optional[Dict]:
|
||||
"""Generate simple momentum-based signal as backup"""
|
||||
@ -1463,51 +1374,16 @@ class CleanTradingDashboard:
|
||||
logger.info(f"Generated {signal['action']} signal for {signal['symbol']} "
|
||||
f"(conf: {signal['confidence']:.2f}, model: {signal.get('model', 'UNKNOWN')})")
|
||||
|
||||
# Trigger training if DQN agent is available
|
||||
if signal.get('model') == 'DQN' and hasattr(self.orchestrator, 'sensitivity_dqn_agent'):
|
||||
if self.orchestrator.sensitivity_dqn_agent is not None:
|
||||
self._train_dqn_on_signal(signal)
|
||||
# DQN training not available in Basic orchestrator
|
||||
# Skip DQN training - Basic orchestrator doesn't support it
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error processing dashboard signal: {e}")
|
||||
|
||||
def _train_dqn_on_signal(self, signal: Dict):
|
||||
"""Train DQN agent on generated signal for continuous learning"""
|
||||
try:
|
||||
dqn_agent = self.orchestrator.sensitivity_dqn_agent
|
||||
|
||||
# Create synthetic training experience
|
||||
current_price = signal['price']
|
||||
action = 0 if signal['action'] == 'SELL' else 1
|
||||
|
||||
# Simulate small price movement for reward calculation
|
||||
import random
|
||||
price_change = random.uniform(-0.001, 0.001) # ±0.1% random movement
|
||||
next_price = current_price * (1 + price_change)
|
||||
|
||||
# Calculate reward based on action correctness
|
||||
if action == 1 and price_change > 0: # BUY and price went up
|
||||
reward = price_change * 10 # Amplify reward
|
||||
elif action == 0 and price_change < 0: # SELL and price went down
|
||||
reward = abs(price_change) * 10
|
||||
else:
|
||||
reward = -0.1 # Small penalty for incorrect prediction
|
||||
|
||||
# Create state vectors (simplified)
|
||||
state = np.random.random(dqn_agent.state_dim if isinstance(dqn_agent.state_dim, int) else dqn_agent.state_dim[0])
|
||||
next_state = state + np.random.normal(0, 0.01, state.shape) # Small state change
|
||||
|
||||
# Add experience to memory
|
||||
dqn_agent.remember(state, action, reward, next_state, True)
|
||||
|
||||
# Trigger training if enough experiences
|
||||
if len(dqn_agent.memory) >= dqn_agent.batch_size:
|
||||
loss = dqn_agent.replay()
|
||||
if loss:
|
||||
logger.debug(f"DQN training loss: {loss:.6f}")
|
||||
|
||||
except Exception as e:
|
||||
logger.debug(f"Error training DQN on signal: {e}")
|
||||
"""Train DQN agent on generated signal - NOT AVAILABLE IN BASIC ORCHESTRATOR"""
|
||||
# Basic orchestrator doesn't have DQN features
|
||||
return
|
||||
|
||||
def _get_cob_dollar_buckets(self) -> List[Dict]:
|
||||
"""Get COB $1 price buckets with volume data"""
|
||||
@ -1843,90 +1719,93 @@ class CleanTradingDashboard:
|
||||
except Exception as e:
|
||||
logger.error(f"Error clearing session: {e}")
|
||||
|
||||
def _initialize_cob_integration(self):
|
||||
"""Initialize REAL COB integration from enhanced orchestrator - NO SIMULATION"""
|
||||
def _initialize_cob_integration_proper(self):
|
||||
"""Initialize COB integration using Enhanced Orchestrator - PROPER APPROACH"""
|
||||
try:
|
||||
logger.info("Connecting to REAL COB integration from enhanced orchestrator...")
|
||||
logger.info("Connecting to COB integration from Enhanced Orchestrator...")
|
||||
|
||||
# Check if orchestrator has real COB integration
|
||||
if not hasattr(self.orchestrator, 'cob_integration') or self.orchestrator.cob_integration is None:
|
||||
logger.error("CRITICAL: Enhanced orchestrator has NO COB integration!")
|
||||
logger.error("This means we're using basic orchestrator instead of enhanced one")
|
||||
logger.error("Dashboard will NOT have real COB data until this is fixed")
|
||||
# Check if we have Enhanced Orchestrator
|
||||
if not ENHANCED_ORCHESTRATOR_AVAILABLE:
|
||||
logger.error("Enhanced Orchestrator not available - COB integration requires Enhanced Orchestrator")
|
||||
return
|
||||
|
||||
# Connect to the real COB integration
|
||||
cob_integration = self.orchestrator.cob_integration
|
||||
logger.info(f"REAL COB integration found: {type(cob_integration)}")
|
||||
# Check if Enhanced Orchestrator has COB integration
|
||||
if not hasattr(self.orchestrator, 'cob_integration'):
|
||||
logger.error("Enhanced Orchestrator has no cob_integration attribute")
|
||||
return
|
||||
|
||||
# Verify COB integration is active and working
|
||||
if hasattr(cob_integration, 'get_statistics'):
|
||||
stats = cob_integration.get_statistics()
|
||||
logger.info(f"COB statistics: {stats}")
|
||||
|
||||
# Register callbacks if available
|
||||
if hasattr(cob_integration, 'add_dashboard_callback'):
|
||||
cob_integration.add_dashboard_callback(self._on_real_cob_update)
|
||||
logger.info("Registered dashboard callback with REAL COB integration")
|
||||
|
||||
# CRITICAL: Start the COB integration if it's not already started
|
||||
# This is the missing piece - the COB integration needs to be started!
|
||||
def start_cob_async():
|
||||
"""Start COB integration in async context"""
|
||||
import asyncio
|
||||
async def _start_cob():
|
||||
try:
|
||||
# Check if COB integration needs to be started
|
||||
if hasattr(self.orchestrator, 'cob_integration_active') and not self.orchestrator.cob_integration_active:
|
||||
logger.info("Starting COB integration from dashboard...")
|
||||
await self.orchestrator.start_cob_integration()
|
||||
logger.info("COB integration started successfully from dashboard")
|
||||
else:
|
||||
logger.info("COB integration already active or starting")
|
||||
|
||||
# Wait a moment for data to start flowing
|
||||
await asyncio.sleep(3)
|
||||
|
||||
# Verify COB data is flowing
|
||||
stats = cob_integration.get_statistics()
|
||||
logger.info(f"COB integration status after start: {stats}")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error starting COB integration from dashboard: {e}")
|
||||
if self.orchestrator.cob_integration is None:
|
||||
logger.warning("Enhanced Orchestrator COB integration is None - needs to be started")
|
||||
|
||||
# Run in new event loop if needed
|
||||
try:
|
||||
loop = asyncio.get_event_loop()
|
||||
if loop.is_running():
|
||||
# If loop is already running, schedule as task
|
||||
asyncio.create_task(_start_cob())
|
||||
else:
|
||||
# If no loop running, run directly
|
||||
loop.run_until_complete(_start_cob())
|
||||
except RuntimeError:
|
||||
# No event loop, create new one
|
||||
asyncio.run(_start_cob())
|
||||
# Try to start the COB integration asynchronously
|
||||
def start_cob_async():
|
||||
"""Start COB integration in async context"""
|
||||
import asyncio
|
||||
async def _start_cob():
|
||||
try:
|
||||
# Start the COB integration from enhanced orchestrator
|
||||
await self.orchestrator.start_cob_integration()
|
||||
logger.info("COB integration started successfully from Enhanced Orchestrator")
|
||||
|
||||
# Register dashboard callback if possible
|
||||
if hasattr(self.orchestrator.cob_integration, 'add_dashboard_callback'):
|
||||
self.orchestrator.cob_integration.add_dashboard_callback(self._on_enhanced_cob_update)
|
||||
logger.info("Registered dashboard callback with Enhanced COB integration")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error starting COB integration from Enhanced Orchestrator: {e}")
|
||||
|
||||
# Run in new event loop if needed
|
||||
try:
|
||||
loop = asyncio.get_event_loop()
|
||||
if loop.is_running():
|
||||
# If loop is already running, schedule as task
|
||||
asyncio.create_task(_start_cob())
|
||||
else:
|
||||
# If no loop running, run directly
|
||||
loop.run_until_complete(_start_cob())
|
||||
except RuntimeError:
|
||||
# No event loop, create new one
|
||||
asyncio.run(_start_cob())
|
||||
|
||||
# Start COB integration in background thread to avoid blocking dashboard
|
||||
import threading
|
||||
cob_start_thread = threading.Thread(target=start_cob_async, daemon=True)
|
||||
cob_start_thread.start()
|
||||
logger.info("Enhanced COB integration startup initiated in background")
|
||||
|
||||
else:
|
||||
# COB integration already exists, just register callback
|
||||
cob_integration = self.orchestrator.cob_integration
|
||||
logger.info(f"Enhanced COB integration found: {type(cob_integration)}")
|
||||
|
||||
# Register callbacks if available
|
||||
if hasattr(cob_integration, 'add_dashboard_callback'):
|
||||
cob_integration.add_dashboard_callback(self._on_enhanced_cob_update)
|
||||
logger.info("Registered dashboard callback with existing Enhanced COB integration")
|
||||
|
||||
# Verify COB integration is active and working
|
||||
if hasattr(cob_integration, 'get_statistics'):
|
||||
try:
|
||||
stats = cob_integration.get_statistics()
|
||||
logger.info(f"Enhanced COB statistics: {stats}")
|
||||
except Exception as e:
|
||||
logger.debug(f"Could not get COB statistics: {e}")
|
||||
|
||||
# Start COB integration in background thread to avoid blocking dashboard
|
||||
import threading
|
||||
cob_start_thread = threading.Thread(target=start_cob_async, daemon=True)
|
||||
cob_start_thread.start()
|
||||
|
||||
logger.info("REAL COB integration connected successfully")
|
||||
logger.info("NO SIMULATION - Using live market data only")
|
||||
logger.info("COB integration startup initiated in background")
|
||||
logger.info("Enhanced COB integration connection completed")
|
||||
logger.info("NO SIMULATION - Using Enhanced Orchestrator real market data only")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"CRITICAL: Failed to connect to REAL COB integration: {e}")
|
||||
logger.error(f"CRITICAL: Failed to connect to Enhanced COB integration: {e}")
|
||||
logger.error("Dashboard will operate without COB data")
|
||||
|
||||
def _on_real_cob_update(self, symbol: str, cob_data: Dict):
|
||||
"""Handle real COB data updates - NO SIMULATION"""
|
||||
|
||||
def _on_enhanced_cob_update(self, symbol: str, cob_data: Dict):
|
||||
"""Handle Enhanced COB data updates - NO SIMULATION"""
|
||||
try:
|
||||
# Process real COB data update
|
||||
# Process Enhanced COB data update
|
||||
current_time = time.time()
|
||||
|
||||
# Update cache with REAL COB data
|
||||
# Update cache with Enhanced COB data (same format as cob_realtime_dashboard.py)
|
||||
if symbol not in self.cob_cache:
|
||||
self.cob_cache[symbol] = {'last_update': 0, 'data': None, 'updates_count': 0}
|
||||
|
||||
@ -1936,13 +1815,16 @@ class CleanTradingDashboard:
|
||||
'updates_count': self.cob_cache[symbol].get('updates_count', 0) + 1
|
||||
}
|
||||
|
||||
# Log real COB data updates
|
||||
# Also update latest_cob_data for compatibility
|
||||
self.latest_cob_data[symbol] = cob_data
|
||||
|
||||
# Log Enhanced COB data updates
|
||||
update_count = self.cob_cache[symbol]['updates_count']
|
||||
if update_count % 50 == 0: # Every 50 real updates
|
||||
logger.info(f"[REAL-COB] {symbol} - Real update #{update_count}")
|
||||
if update_count % 50 == 0: # Every 50 Enhanced updates
|
||||
logger.info(f"[ENHANCED-COB] {symbol} - Enhanced update #{update_count}")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error handling REAL COB update for {symbol}: {e}")
|
||||
logger.error(f"Error handling Enhanced COB update for {symbol}: {e}")
|
||||
|
||||
def _start_cob_data_subscription(self):
|
||||
"""Start COB data subscription with proper caching"""
|
||||
@ -2226,6 +2108,10 @@ class CleanTradingDashboard:
|
||||
def _start_unified_stream(self):
|
||||
"""Start the unified data stream in background"""
|
||||
try:
|
||||
if self.unified_stream is None:
|
||||
logger.warning("Unified stream is None - cannot start")
|
||||
return
|
||||
|
||||
import asyncio
|
||||
loop = asyncio.new_event_loop()
|
||||
asyncio.set_event_loop(loop)
|
||||
@ -2429,7 +2315,7 @@ class CleanTradingDashboard:
|
||||
}
|
||||
|
||||
|
||||
def create_clean_dashboard(data_provider=None, orchestrator=None, trading_executor=None):
|
||||
def create_clean_dashboard(data_provider: Optional[DataProvider] = None, orchestrator: Optional[TradingOrchestrator] = None, trading_executor: Optional[TradingExecutor] = None):
|
||||
"""Factory function to create a CleanTradingDashboard instance"""
|
||||
return CleanTradingDashboard(
|
||||
data_provider=data_provider,
|
||||
|
||||
Reference in New Issue
Block a user