Delete src

src/agents/advanced_agent.py

@@ -1,310 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import numpy as np
-from collections import deque
-import random
-import warnings
-warnings.filterwarnings('ignore')
-
-class EnhancedTradingNetwork(nn.Module):
-    def __init__(self, state_dim, action_dim, sentiment_dim=2):
-        super(EnhancedTradingNetwork, self).__init__()
-       
-        # Visual processing branch
-        self.visual_conv = nn.Sequential(
-            nn.Conv2d(4, 16, kernel_size=4, stride=2),
-            nn.ReLU(),
-            nn.Conv2d(16, 32, kernel_size=4, stride=2),
-            nn.ReLU(),
-            nn.Conv2d(32, 32, kernel_size=3, stride=1),
-            nn.ReLU(),
-            nn.AdaptiveAvgPool2d((8, 8))
-        )
-       
-        # Calculate the output size after conv layers
-        self.conv_output_size = 32 * 8 * 8
-       
-        self.visual_fc = nn.Sequential(
-            nn.Linear(self.conv_output_size, 256),
-            nn.ReLU(),
-            nn.Dropout(0.3)
-        )
-       
-        # Sentiment processing branch
-        self.sentiment_fc = nn.Sequential(
-            nn.Linear(sentiment_dim, 64),
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(64, 32),
-            nn.ReLU()
-        )
-       
-        # Combined decision making
-        self.combined_fc = nn.Sequential(
-            nn.Linear(256 + 32, 128),
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(128, 64),
-            nn.ReLU(),
-            nn.Linear(64, action_dim)
-        )
-       
-        # Store action_dim for error handling
-        self.action_dim = action_dim
-       
-    def forward(self, x, sentiment=None):
-        try:
-            # Ensure input has batch dimension
-            if len(x.shape) == 3:  # (H, W, C)
-                x = x.unsqueeze(0)
-            elif len(x.shape) == 4:  # (batch, H, W, C)
-                pass
-            else:
-                raise ValueError(f"Invalid input shape: {x.shape}")
-            
-            # Permute to (batch, C, H, W)
-            x = x.permute(0, 3, 1, 2).contiguous().float()
-            
-            # Check if channels match expected input
-            if x.size(1) != 4:
-                raise ValueError(f"Expected 4 channels, got {x.size(1)}")
-            
-            visual_features = self.visual_conv(x)
-            batch_size = visual_features.size(0)
-            visual_features = visual_features.reshape(batch_size, -1)
-            visual_features = self.visual_fc(visual_features)
-           
-            # Sentiment processing
-            if sentiment is not None and self.sentiment_fc is not None:
-                if len(sentiment.shape) == 1:
-                    sentiment = sentiment.unsqueeze(0)
-                sentiment = sentiment.float()
-                sentiment_features = self.sentiment_fc(sentiment)
-                combined_features = torch.cat([visual_features, sentiment_features], dim=1)
-            else:
-                # Pad with zeros if no sentiment
-                sentiment_features = torch.zeros(batch_size, 32, device=visual_features.device)
-                combined_features = torch.cat([visual_features, sentiment_features], dim=1)
-           
-            q_values = self.combined_fc(combined_features)
-            return q_values
-           
-        except Exception as e:
-            print(f"Error in network forward: {e}")
-            print(f"Input shape: {getattr(x, 'shape', 'Unknown')}")
-            # Return safe default with correct shape
-            batch_size = x.size(0) if hasattr(x, 'size') else 1
-            return torch.zeros(batch_size, self.action_dim, device=(x.device if hasattr(x, 'device') else 'cpu'))
-
-class AdvancedTradingAgent:
-    def __init__(self, state_dim, action_dim, learning_rate=0.001, use_sentiment=True):
-        self.state_dim = state_dim  # Should be (84, 84, 4) or similar
-        self.action_dim = action_dim
-        self.learning_rate = learning_rate
-        self.use_sentiment = use_sentiment
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        print(f"Using device: {self.device}")
-       
-        # Neural network
-        self.policy_net = EnhancedTradingNetwork(state_dim, action_dim).to(self.device)
-        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=learning_rate)
-        self.loss_fn = nn.MSELoss()
-       
-        # Experience replay
-        self.memory = deque(maxlen=10000)  # Increased buffer size
-        self.batch_size = min(32, state_dim[0]//2)  # Dynamic batch size
-       
-        # Training parameters
-        self.gamma = 0.99
-        self.epsilon = 1.0
-        self.epsilon_min = 0.01  # More aggressive exploration decay
-        self.epsilon_decay = 0.9995  # Slower decay
-        self.steps_done = 0
-        self.target_update_freq = 100  # Target network update frequency
-        self.steps_since_target_update = 0
-       
-    def select_action(self, state, current_sentiment=None, sentiment_confidence=None):
-        """Select action with epsilon-greedy policy"""
-        if random.random() < self.epsilon:
-            return random.randint(0, self.action_dim - 1)
-       
-        try:
-            # Validate and normalize state
-            if not isinstance(state, np.ndarray):
-                state = np.array(state)
-            
-            if state.dtype != np.float32:
-                state = state.astype(np.float32)
-            
-            # Normalize pixel values
-            if state.max() > 1.0:
-                state = state / 255.0
-            
-            state_tensor = torch.FloatTensor(state).to(self.device)
-           
-            # Prepare sentiment input
-            if self.use_sentiment and current_sentiment is not None:
-                sentiment = np.array([float(current_sentiment), float(sentiment_confidence or 0.0)])
-                sentiment_tensor = torch.FloatTensor(sentiment).to(self.device)
-                with torch.no_grad():
-                    q_values = self.policy_net(state_tensor, sentiment_tensor)
-            else:
-                with torch.no_grad():
-                    q_values = self.policy_net(state_tensor)
-           
-            action = int(q_values.argmax().item())
-            return action
-           
-        except Exception as e:
-            print(f"Error in action selection: {e}")
-            return random.randint(0, self.action_dim - 1)
-   
-    def store_transition(self, state, action, reward, next_state, done, sentiment_data=None):
-        """Store experience tuple safely"""
-        try:
-            # Ensure all inputs are numpy arrays
-            if not isinstance(state, np.ndarray):
-                state = np.array(state, dtype=np.float32)
-            if not isinstance(next_state, np.ndarray):
-                next_state = np.array(next_state, dtype=np.float32)
-            
-            # Normalize before storing
-            if state.max() > 1.0:
-                state = state / 255.0
-            if next_state.max() > 1.0:
-                next_state = next_state / 255.0
-            
-            # Handle sentiment data
-            if sentiment_data is None:
-                sentiment_data = {'sentiment': 0.5, 'confidence': 0.0}
-            
-            experience = (state, action, float(reward), next_state, bool(done), sentiment_data)
-            self.memory.append(experience)
-            
-        except Exception as e:
-            print(f"Error storing transition: {e}")
-   
-    def update(self):
-        """DQN update with improved stability"""
-        if len(self.memory) < self.batch_size:
-            return 0.0
-       
-        try:
-            batch = random.sample(self.memory, self.batch_size)
-            states, actions, rewards, next_states, dones, sentiments = zip(*batch)
-           
-            # Convert to tensors
-            states = np.stack(states)
-            next_states = np.stack(next_states)
-            actions = np.array(actions)
-            rewards = np.array(rewards)
-            dones = np.array(dones)
-            
-            states_tensor = torch.FloatTensor(states).to(self.device)
-            next_states_tensor = torch.FloatTensor(next_states).to(self.device)
-            actions_tensor = torch.LongTensor(actions).to(self.device)
-            rewards_tensor = torch.FloatTensor(rewards).to(self.device)
-            dones_tensor = torch.BoolTensor(dones).to(self.device)
-           
-            # Compute current Q values
-            if self.use_sentiment:
-                # Use sentiment from current state
-                sentiment_batch = []
-                for sentiment_data in sentiments:
-                    sentiment = [sentiment_data.get('sentiment', 0.5), 
-                               sentiment_data.get('confidence', 0.0)]
-                    sentiment_batch.append(sentiment)
-                sentiment_tensor = torch.FloatTensor(sentiment_batch).to(self.device)
-                current_q = self.policy_net(states_tensor, sentiment_tensor)
-            else:
-                current_q = self.policy_net(states_tensor)
-            
-            current_q = current_q.gather(1, actions_tensor.unsqueeze(1)).squeeze(1)
-           
-            # Compute target Q values
-            with torch.no_grad():
-                if self.use_sentiment:
-                    next_sentiment_batch = []
-                    for sentiment_data in sentiments:
-                        next_sentiment = [sentiment_data.get('sentiment', 0.5), 
-                                        sentiment_data.get('confidence', 0.0)]
-                        next_sentiment_batch.append(next_sentiment)
-                    next_sentiment_tensor = torch.FloatTensor(next_sentiment_batch).to(self.device)
-                    next_q = self.policy_net(next_states_tensor, next_sentiment_tensor)
-                else:
-                    next_q = self.policy_net(next_states_tensor)
-                
-                next_q_max = next_q.max(1)[0]
-                target_q = rewards_tensor + (self.gamma * next_q_max * ~dones_tensor)
-           
-            # Compute loss and optimize
-            loss = self.loss_fn(current_q, target_q)
-           
-            self.optimizer.zero_grad()
-            loss.backward()
-            torch.nn.utils.clip_grad_norm_(self.policy_net.parameters(), 1.0)
-            self.optimizer.step()
-           
-            # Update epsilon
-            if self.epsilon > self.epsilon_min:
-                self.epsilon *= self.epsilon_decay
-           
-            self.steps_done += 1
-            self.steps_since_target_update += 1
-            
-            # Update target network periodically (if implemented)
-            if self.steps_since_target_update % self.target_update_freq == 0:
-                self._update_target_network()
-           
-            return float(loss.item())
-           
-        except Exception as e:
-            print(f"Error in update: {e}")
-            import traceback
-            traceback.print_exc()
-            return 0.0
-    
-    def _update_target_network(self):
-        """Update target network (placeholder for double DQN)"""
-        pass  # Implement target network update here
-
-# Simple fallback network
-class SimpleTradingNetwork(nn.Module):
-    def __init__(self, state_dim, action_dim):
-        super(SimpleTradingNetwork, self).__init__()
-        self.action_dim = action_dim
-       
-        self.conv_layers = nn.Sequential(
-            nn.Conv2d(4, 16, kernel_size=4, stride=2),
-            nn.ReLU(),
-            nn.Conv2d(16, 32, kernel_size=4, stride=2),
-            nn.ReLU(),
-            nn.Conv2d(32, 32, kernel_size=3, stride=1),
-            nn.ReLU(),
-            nn.AdaptiveAvgPool2d((8, 8))
-        )
-       
-        self.fc_layers = nn.Sequential(
-            nn.Linear(32 * 8 * 8, 128),
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(128, 64),
-            nn.ReLU(),
-            nn.Linear(64, action_dim)
-        )
-       
-    def forward(self, x):
-        try:
-            if len(x.shape) == 3:
-                x = x.unsqueeze(0)
-            x = x.permute(0, 3, 1, 2).contiguous().float()
-            
-            x = self.conv_layers(x)
-            x = x.reshape(x.size(0), -1)
-            x = self.fc_layers(x)
-            return x
-        except Exception as e:
-            print(f"Error in simple network: {e}")
-            batch_size = x.size(0) if hasattr(x, 'size') else 1
-            return torch.zeros(batch_size, self.action_dim, device=(x.device if hasattr(x, 'device') else 'cpu'))

src/agents/visual_agent.py

@@ -1,153 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import numpy as np
-from collections import deque
-import random
-
-class SimpleTradingNetwork(nn.Module):
-    def __init__(self, state_dim, action_dim):
-        super(SimpleTradingNetwork, self).__init__()
-        
-        # Simplified CNN for faster training
-        self.conv_layers = nn.Sequential(
-            nn.Conv2d(4, 16, kernel_size=4, stride=2),  # Input: 84x84x4 -> 41x41x16
-            nn.ReLU(),
-            nn.Conv2d(16, 32, kernel_size=4, stride=2), # 41x41x16 -> 19x19x32
-            nn.ReLU(),
-            nn.Conv2d(32, 32, kernel_size=3, stride=1), # 19x19x32 -> 17x17x32
-            nn.ReLU(),
-            nn.AdaptiveAvgPool2d((8, 8))  # 17x17x32 -> 8x8x32
-        )
-        
-        # Calculate flattened size
-        self.flattened_size = 32 * 8 * 8
-        
-        # Fully connected layers
-        self.fc_layers = nn.Sequential(
-            nn.Linear(self.flattened_size, 128),
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(128, 64),
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(64, action_dim)
-        )
-        
-    def forward(self, x):
-        try:
-            # x shape: (batch_size, 84, 84, 4) -> (batch_size, 4, 84, 84)
-            if len(x.shape) == 4:  # Single observation
-                x = x.permute(0, 3, 1, 2)
-            else:  # Batch of observations
-                x = x.permute(0, 3, 1, 2)
-                
-            x = self.conv_layers(x)
-            x = x.view(x.size(0), -1)
-            x = self.fc_layers(x)
-            return x
-        except Exception as e:
-            print(f"Error in network forward: {e}")
-            # Return zeros in case of error
-            return torch.zeros((x.size(0), self.fc_layers[-1].out_features))
-
-class VisualTradingAgent:
-    def __init__(self, state_dim, action_dim, learning_rate=0.001):
-        self.state_dim = state_dim
-        self.action_dim = action_dim
-        self.learning_rate = learning_rate
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        print(f"Using device: {self.device}")
-        
-        # Neural network
-        self.policy_net = SimpleTradingNetwork(state_dim, action_dim).to(self.device)
-        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=learning_rate)
-        
-        # Experience replay
-        self.memory = deque(maxlen=500)  # Smaller memory for stability
-        self.batch_size = 16
-        
-        # Training parameters
-        self.gamma = 0.99
-        self.epsilon = 1.0
-        self.epsilon_min = 0.1
-        self.epsilon_decay = 0.995
-        self.update_target_every = 100
-        self.steps_done = 0
-        
-    def select_action(self, state):
-        """Select action using epsilon-greedy policy"""
-        if random.random() < self.epsilon:
-            return random.randint(0, self.action_dim - 1)
-        
-        try:
-            # Normalize state and convert to tensor
-            state_normalized = state.astype(np.float32) / 255.0
-            state_tensor = torch.FloatTensor(state_normalized).unsqueeze(0).to(self.device)
-            
-            with torch.no_grad():
-                q_values = self.policy_net(state_tensor)
-            return int(q_values.argmax().item())
-        except Exception as e:
-            print(f"Error in action selection: {e}")
-            return random.randint(0, self.action_dim - 1)
-    
-    def store_transition(self, state, action, reward, next_state, done):
-        """Store experience in replay memory"""
-        try:
-            self.memory.append((state, action, reward, next_state, done))
-        except Exception as e:
-            print(f"Error storing transition: {e}")
-    
-    def update(self):
-        """Update the neural network"""
-        if len(self.memory) < self.batch_size:
-            return 0.0
-        
-        try:
-            # Sample batch from memory
-            batch = random.sample(self.memory, self.batch_size)
-            states, actions, rewards, next_states, dones = zip(*batch)
-            
-            # Convert to tensors with normalization
-            states_array = np.array(states, dtype=np.float32) / 255.0
-            next_states_array = np.array(next_states, dtype=np.float32) / 255.0
-            
-            states_tensor = torch.FloatTensor(states_array).to(self.device)
-            actions_tensor = torch.LongTensor(actions).to(self.device)
-            rewards_tensor = torch.FloatTensor(rewards).to(self.device)
-            next_states_tensor = torch.FloatTensor(next_states_array).to(self.device)
-            dones_tensor = torch.BoolTensor(dones).to(self.device)
-            
-            # Current Q values
-            current_q = self.policy_net(states_tensor).gather(1, actions_tensor.unsqueeze(1))
-            
-            # Next Q values
-            with torch.no_grad():
-                next_q = self.policy_net(next_states_tensor).max(1)[0]
-                target_q = rewards_tensor + (self.gamma * next_q * ~dones_tensor)
-            
-            # Compute loss
-            loss = nn.MSELoss()(current_q.squeeze(), target_q)
-            
-            # Optimize
-            self.optimizer.zero_grad()
-            loss.backward()
-            
-            # Gradient clipping for stability
-            torch.nn.utils.clip_grad_norm_(self.policy_net.parameters(), 1.0)
-            self.optimizer.step()
-            
-            # Update steps and decay epsilon
-            self.steps_done += 1
-            if self.steps_done % self.update_target_every == 0:
-                # For simplicity, we're using the same network
-                pass
-            
-            self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)
-            
-            return float(loss.item())
-            
-        except Exception as e:
-            print(f"Error in update: {e}")
-            return 0.0

src/environments/advanced_trading_env.py

@@ -1,293 +0,0 @@
-import numpy as np
-import logging
-from typing import Dict, Any, Optional, Tuple
-from .visual_trading_env import VisualTradingEnvironment
-from src.sentiment.twitter_analyzer import AdvancedSentimentAnalyzer
-
-# Setup logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class AdvancedTradingEnvironment(VisualTradingEnvironment):
-    def __init__(self, initial_balance=10000, risk_level="Medium", asset_type="Crypto",
-                 use_sentiment=True, sentiment_influence=0.3, sentiment_update_freq=5):
-        super().__init__(initial_balance, risk_level, asset_type)
-       
-        # Validate inputs
-        if not 0.0 <= sentiment_influence <= 1.0:
-            raise ValueError("sentiment_influence must be between 0.0 and 1.0")
-        if sentiment_update_freq < 1:
-            raise ValueError("sentiment_update_freq must be at least 1")
-       
-        self.use_sentiment = use_sentiment
-        self.sentiment_influence = sentiment_influence
-        self.sentiment_update_freq = sentiment_update_freq
-        self.sentiment_history = deque(maxlen=100)  # Limited history
-        self.current_step = 0
-       
-        # Sentiment analyzer with error handling
-        self.sentiment_analyzer = None
-        self.current_sentiment = 0.5
-        self.sentiment_confidence = 0.0
-        
-        if use_sentiment:
-            try:
-                self.sentiment_analyzer = AdvancedSentimentAnalyzer()
-                self.sentiment_analyzer.initialize_models()
-                logger.info("Sentiment analyzer initialized successfully")
-            except Exception as e:
-                logger.warning(f"Failed to initialize sentiment analyzer: {e}. Disabling sentiment.")
-                self.use_sentiment = False
-       
-    def step(self, action: int) -> Tuple[np.ndarray, float, bool, Dict[str, Any]]:
-        """Execute trading step with sentiment influence"""
-        if not isinstance(action, int) or action < 0:
-            logger.warning(f"Invalid action {action}, defaulting to hold")
-            action = 0  # Hold action as default
-        
-        # Update sentiment periodically
-        if self.use_sentiment and self.current_step % self.sentiment_update_freq == 0:
-            self._update_sentiment()
-        
-        self.current_step += 1
-        
-        # Execute base environment step
-        try:
-            observation, reward, done, info = super().step(action)
-        except Exception as e:
-            logger.error(f"Error in base environment step: {e}")
-            # Return safe defaults
-            observation = self._get_safe_observation()
-            reward = 0.0
-            done = False
-            info = {}
-        
-        # Apply sentiment modification to reward
-        if self.use_sentiment:
-            try:
-                reward = self._apply_sentiment_to_reward(reward, action, info)
-            except Exception as e:
-                logger.warning(f"Error applying sentiment to reward: {e}")
-        
-        # Enhance observation with sentiment (optional)
-        enhanced_observation = self._enhance_observation(observation)
-        
-        # Add sentiment info to info dict
-        info.update({
-            'sentiment': float(self.current_sentiment),
-            'sentiment_confidence': float(self.sentiment_confidence),
-            'sentiment_influence': float(self.sentiment_influence),
-            'step': self.current_step
-        })
-        
-        return enhanced_observation, float(reward), bool(done), info
-   
-    def _update_sentiment(self):
-        """Update current market sentiment with robust error handling"""
-        if not self.sentiment_analyzer:
-            return
-        
-        try:
-            sentiment_data = self.sentiment_analyzer.get_influencer_sentiment()
-            
-            # Validate sentiment data
-            if not isinstance(sentiment_data, dict):
-                raise ValueError("Invalid sentiment data format")
-            
-            market_sentiment = sentiment_data.get('market_sentiment')
-            confidence = sentiment_data.get('confidence')
-            
-            if market_sentiment is None or not (-1.0 <= market_sentiment <= 1.0):
-                raise ValueError("Invalid market_sentiment value")
-            if confidence is None or not (0.0 <= confidence <= 1.0):
-                raise ValueError("Invalid confidence value")
-            
-            self.current_sentiment = float(market_sentiment)
-            self.sentiment_confidence = float(confidence)
-            
-            # Normalize sentiment to 0-1 range for consistency
-            self.current_sentiment = (self.current_sentiment + 1.0) / 2.0
-            
-            # Update history
-            self.sentiment_history.append({
-                'sentiment': self.current_sentiment,
-                'confidence': self.sentiment_confidence,
-                'timestamp': self.current_step
-            })
-            
-            logger.debug(f"Updated sentiment: {self.current_sentiment:.3f} (conf: {self.sentiment_confidence:.3f})")
-            
-        except Exception as e:
-            logger.warning(f"Error updating sentiment: {e}")
-            # Fallback to neutral sentiment
-            self.current_sentiment = 0.5
-            self.sentiment_confidence = 0.0
-            self.sentiment_history.append({
-                'sentiment': 0.5,
-                'confidence': 0.0,
-                'timestamp': self.current_step
-            })
-   
-    def _apply_sentiment_to_reward(self, original_reward: float, action: int, 
-                                 info: Dict[str, Any]) -> float:
-        """Modify reward based on sentiment analysis with bounds checking"""
-        if self.sentiment_confidence < 0.3:
-            return original_reward
-        
-        try:
-            sentiment_multiplier = 1.0
-            sentiment_score = self.current_sentiment  # 0-1 normalized
-            
-            # Define action mappings (adjust based on your action space)
-            # Assuming: 0=hold, 1=buy, 2=sell, 3=close
-            bullish_threshold = 0.6
-            bearish_threshold = 0.4
-            
-            if sentiment_score > bullish_threshold:  # Bullish
-                if action == 1:  # Buy
-                    sentiment_multiplier += self.sentiment_influence * self.sentiment_confidence
-                elif action == 2:  # Sell short
-                    sentiment_multiplier -= self.sentiment_influence * 0.3 * self.sentiment_confidence
-                elif action == 3:  # Close
-                    sentiment_multiplier -= self.sentiment_influence * 0.2 * self.sentiment_confidence
-                
-            elif sentiment_score < bearish_threshold:  # Bearish
-                if action == 2:  # Sell short
-                    sentiment_multiplier += self.sentiment_influence * self.sentiment_confidence
-                elif action == 1:  # Buy
-                    sentiment_multiplier -= self.sentiment_influence * 0.5 * self.sentiment_confidence
-                elif action == 3:  # Close
-                    sentiment_multiplier += self.sentiment_influence * 0.3 * self.sentiment_confidence
-            
-            # Apply trend momentum if enough history
-            trend_multiplier = self._calculate_sentiment_trend_multiplier()
-            sentiment_multiplier += trend_multiplier
-            
-            # Clamp multiplier to reasonable bounds
-            sentiment_multiplier = np.clip(sentiment_multiplier, 0.5, 2.0)
-            
-            enhanced_reward = original_reward * sentiment_multiplier
-            
-            # Ensure reward doesn't become extreme
-            max_reward = abs(original_reward) * 2.5 if original_reward != 0 else 10.0
-            return np.clip(enhanced_reward, -max_reward, max_reward)
-            
-        except Exception as e:
-            logger.error(f"Error in sentiment reward calculation: {e}")
-            return original_reward
-   
-    def _calculate_sentiment_trend_multiplier(self) -> float:
-        """Calculate trend-based multiplier from sentiment history"""
-        if len(self.sentiment_history) < 10:
-            return 0.0
-        
-        try:
-            # Get recent and previous sentiment values
-            recent_sentiments = [h['sentiment'] for h in list(self.sentiment_history)[-5:]]
-            prev_sentiments = [h['sentiment'] for h in list(self.sentiment_history)[-10:-5]]
-            
-            recent_avg = np.mean(recent_sentiments)
-            prev_avg = np.mean(prev_sentiments)
-            
-            trend = recent_avg - prev_avg
-            # Scale trend influence
-            trend_multiplier = np.tanh(trend * 5) * self.sentiment_influence * 0.3
-            return float(trend_multiplier)
-            
-        except Exception as e:
-            logger.warning(f"Error calculating trend multiplier: {e}")
-            return 0.0
-   
-    def _enhance_observation(self, original_observation: np.ndarray) -> np.ndarray:
-        """Enhance observation with sentiment information"""
-        if not self.use_sentiment or original_observation is None:
-            return original_observation
-        
-        try:
-            # For now, return original observation
-            # Future: could concatenate sentiment as additional channels or metadata
-            return original_observation.copy()
-        except Exception as e:
-            logger.warning(f"Error enhancing observation: {e}")
-            return original_observation
-   
-    def _get_safe_observation(self) -> np.ndarray:
-        """Get a safe default observation"""
-        try:
-            # Try to get current observation from base env
-            if hasattr(self, 'current_observation'):
-                return self.current_observation.copy()
-            # Return zero observation of expected shape
-            return np.zeros((84, 84, 4), dtype=np.float32)
-        except:
-            return np.zeros((84, 84, 4), dtype=np.float32)
-   
-    def get_sentiment_analysis(self) -> Dict[str, Any]:
-        """Get detailed sentiment analysis with safety checks"""
-        if not self.use_sentiment:
-            return {"error": "Sentiment analysis disabled", "sentiment": 0.5, "confidence": 0.0}
-       
-        try:
-            trend_direction = self._calculate_sentiment_trend_direction()
-            return {
-                "current_sentiment": float(self.current_sentiment),
-                "sentiment_confidence": float(self.sentiment_confidence),
-                "sentiment_trend": trend_direction,
-                "influence_level": float(self.sentiment_influence),
-                "history_length": len(self.sentiment_history),
-                "update_freq": self.sentiment_update_freq,
-                "last_update_step": self.current_step
-            }
-        except Exception as e:
-            logger.error(f"Error in get_sentiment_analysis: {e}")
-            return {
-                "error": str(e),
-                "sentiment": 0.5,
-                "confidence": 0.0,
-                "trend": "unknown"
-            }
-   
-    def _calculate_sentiment_trend_direction(self) -> str:
-        """Calculate sentiment trend direction"""
-        if len(self.sentiment_history) < 5:
-            return "insufficient_data"
-        
-        try:
-            recent_avg = np.mean([h['sentiment'] for h in list(self.sentiment_history)[-5:]])
-            prev_avg = np.mean([h['sentiment'] for h in list(self.sentiment_history)[-10:-5]]) if len(self.sentiment_history) >= 10 else recent_avg
-            
-            diff = recent_avg - prev_avg
-            if diff > 0.05:
-                return "bullish"
-            elif diff < -0.05:
-                return "bearish"
-            else:
-                return "neutral"
-        except:
-            return "error"
-   
-    def reset(self) -> np.ndarray:
-        """Reset environment with sentiment state"""
-        try:
-            observation = super().reset()
-            self.current_step = 0
-            self.sentiment_history.clear()
-            self.current_sentiment = 0.5
-            self.sentiment_confidence = 0.0
-            logger.info("Environment reset with sentiment state")
-            return observation
-        except Exception as e:
-            logger.error(f"Error in reset: {e}")
-            # Force safe reset
-            super().reset()
-            self.current_step = 0
-            self.sentiment_history.clear()
-            return np.zeros((84, 84, 4), dtype=np.float32)
-    
-    @property
-    def action_space_size(self) -> int:
-        """Get action space size from base environment"""
-        try:
-            return super().action_space.n if hasattr(super(), 'action_space') else 4
-        except:
-            return 4  # Default assumption

src/environments/visual_trading_env.py

@@ -1,228 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-from PIL import Image
-import io
-
-class VisualTradingEnvironment:
-    def __init__(self, initial_balance=10000, risk_level="Medium", asset_type="Stock"):
-        self.initial_balance = float(initial_balance)
-        self.risk_level = risk_level
-        self.asset_type = asset_type
-        
-        # Risk multipliers
-        risk_multipliers = {"Low": 0.5, "Medium": 1.0, "High": 2.0}
-        self.risk_multiplier = risk_multipliers.get(risk_level, 1.0)
-        
-        # Generate market data
-        self._generate_market_data()
-        
-        # Initialize state
-        self.reset()
-    
-    def _generate_market_data(self, num_points=1000):
-        """Generate realistic synthetic market data"""
-        np.random.seed(42)
-        
-        # Base parameters based on asset type
-        base_params = {
-            "Stock": {"volatility": 0.01, "trend": 0.0005},
-            "Crypto": {"volatility": 0.02, "trend": 0.001},
-            "Forex": {"volatility": 0.005, "trend": 0.0002}
-        }
-        
-        params = base_params.get(self.asset_type, base_params["Stock"])
-        volatility = params["volatility"] * self.risk_multiplier
-        trend = params["trend"]
-        
-        prices = [100.0]
-        for i in range(1, num_points):
-            # Random walk with trend and some mean reversion
-            change = np.random.normal(trend, volatility)
-            # Add some mean reversion
-            mean_reversion = (100 - prices[-1]) * 0.001
-            price = max(1.0, prices[-1] * (1 + change) + mean_reversion)
-            prices.append(price)
-        
-        self.price_data = np.array(prices)
-    
-    def _get_visual_observation(self):
-        """Generate visual representation of current market state"""
-        try:
-            # Get recent price window
-            window_size = 50
-            start_idx = max(0, self.current_step - window_size)
-            end_idx = self.current_step + 1
-            
-            if end_idx > len(self.price_data):
-                end_idx = len(self.price_data)
-            
-            prices = self.price_data[start_idx:end_idx]
-            
-            # Create matplotlib figure with fixed size
-            fig, ax = plt.subplots(figsize=(4.2, 4.2), dpi=20, facecolor='black')
-            ax.set_facecolor('black')
-            
-            # Plot price if we have data
-            if len(prices) > 0:
-                ax.plot(prices, color='cyan', linewidth=1.5)
-            
-            # Remove axes for cleaner visual
-            ax.set_xticks([])
-            ax.set_yticks([])
-            ax.spines['top'].set_visible(False)
-            ax.spines['right'].set_visible(False)
-            ax.spines['bottom'].set_visible(False)
-            ax.spines['left'].set_visible(False)
-            
-            # Set fixed limits to ensure consistent size
-            ax.set_xlim(0, 50)
-            if len(prices) > 0:
-                price_min, price_max = min(prices), max(prices)
-                price_range = price_max - price_min
-                if price_range == 0:
-                    price_range = 1
-                ax.set_ylim(price_min - price_range * 0.1, price_max + price_range * 0.1)
-            else:
-                ax.set_ylim(0, 100)
-            
-            # Convert to numpy array with consistent size
-            buf = io.BytesIO()
-            plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0, facecolor='black', dpi=20)
-            buf.seek(0)
-            img = Image.open(buf).convert('RGB')
-            
-            # Resize to consistent dimensions
-            img = img.resize((84, 84), Image.Resampling.LANCZOS)
-            img_array = np.array(img)
-            
-            plt.close(fig)
-            
-            # Create attention map with same dimensions
-            attention_map = np.zeros((84, 84), dtype=np.uint8)
-            if len(prices) > 1:
-                recent_change = (prices[-1] - prices[-2]) / prices[-2]
-                intensity = min(255, abs(recent_change) * 5000)
-                
-                # Simple attention based on price movement
-                center_x, center_y = 42, 42
-                size = max(5, int(intensity / 50))
-                
-                for i in range(max(0, center_x-size), min(84, center_x+size)):
-                    for j in range(max(0, center_y-size), min(84, center_y+size)):
-                        distance = np.sqrt((i-center_x)**2 + (j-center_y)**2)
-                        if distance <= size:
-                            attention_value = intensity * (1 - distance/size)
-                            attention_map[i, j] = max(attention_map[i, j], int(attention_value))
-            
-            # Combine RGB with attention map
-            visual_obs = np.concatenate([
-                img_array, 
-                attention_map[:, :, np.newaxis]  # Add channel dimension
-            ], axis=2)
-            
-            return visual_obs
-            
-        except Exception as e:
-            print(f"Error in visual observation: {e}")
-            # Return default observation in case of error
-            return np.zeros((84, 84, 4), dtype=np.uint8)
-    
-    def reset(self):
-        """Reset environment to initial state"""
-        self.current_step = 50  # Start with some history
-        self.balance = self.initial_balance
-        self.position_size = 0.0
-        self.entry_price = 0.0
-        self.net_worth = self.initial_balance
-        self.total_trades = 0
-        self.done = False
-        
-        return self._get_visual_observation()
-    
-    def step(self, action):
-        """Execute one trading step"""
-        try:
-            current_price = self.price_data[self.current_step]
-            prev_net_worth = self.net_worth
-            
-            reward = 0.0
-            
-            # Execute action
-            if action == 1 and self.position_size == 0:  # Buy
-                # Risk-adjusted position sizing
-                position_value = self.balance * 0.1 * self.risk_multiplier
-                self.position_size = position_value / current_price
-                self.entry_price = current_price
-                self.balance -= position_value
-                self.total_trades += 1
-                reward = -0.01  # Small penalty for transaction
-                
-            elif action == 2 and self.position_size > 0:  # Sell (increase position)
-                additional_value = self.balance * 0.05 * self.risk_multiplier
-                additional_size = additional_value / current_price
-                self.position_size += additional_size
-                self.balance -= additional_value
-                self.total_trades += 1
-                reward = -0.005
-                
-            elif action == 3 and self.position_size > 0:  # Close position
-                close_value = self.position_size * current_price
-                self.balance += close_value
-                if self.entry_price > 0:
-                    profit_loss = (current_price - self.entry_price) / self.entry_price
-                    reward = profit_loss * 10  # Scale profit/loss
-                self.position_size = 0.0
-                self.entry_price = 0.0
-                self.total_trades += 1
-            
-            # Update net worth
-            position_value = self.position_size * current_price if self.position_size > 0 else 0.0
-            self.net_worth = self.balance + position_value
-            
-            # Add small reward for portfolio growth
-            if prev_net_worth > 0:
-                portfolio_change = (self.net_worth - prev_net_worth) / prev_net_worth
-                reward += portfolio_change * 5
-            
-            # Move to next step
-            self.current_step += 1
-            
-            # Check if episode is done
-            if self.current_step >= len(self.price_data) - 1:
-                self.done = True
-                # Final reward based on overall performance
-                if self.initial_balance > 0:
-                    final_return = (self.net_worth - self.initial_balance) / self.initial_balance
-                    reward += final_return * 20
-            
-            info = {
-                'net_worth': float(self.net_worth),
-                'balance': float(self.balance),
-                'position_size': float(self.position_size),
-                'current_price': float(current_price),
-                'total_trades': int(self.total_trades),
-                'step': int(self.current_step)
-            }
-            
-            obs = self._get_visual_observation()
-            return obs, float(reward), bool(self.done), info
-            
-        except Exception as e:
-            print(f"Error in step execution: {e}")
-            # Return safe default values in case of error
-            default_info = {
-                'net_worth': float(self.initial_balance),
-                'balance': float(self.initial_balance),
-                'position_size': 0.0,
-                'current_price': 100.0,
-                'total_trades': 0,
-                'step': int(self.current_step)
-            }
-            return self._get_visual_observation(), 0.0, True, default_info
-    
-    def get_price_history(self):
-        """Get recent price history for visualization"""
-        window_size = min(50, self.current_step)
-        start_idx = max(0, self.current_step - window_size)
-        prices = self.price_data[start_idx:self.current_step]
-        return [float(price) for price in prices]

src/sentiment/twitter_analyzer.py

@@ -1,495 +0,0 @@
-import torch
-import numpy as np
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
-from textblob import TextBlob
-from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-from typing import Dict, List, Tuple, Optional
-import time
-from datetime import datetime, timedelta
-import re
-import logging
-from functools import lru_cache
-import warnings
-warnings.filterwarnings('ignore')
-
-# Setup logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class AdvancedSentimentAnalyzer:
-    def __init__(self, max_model_retries=3, cache_size=100):
-        self.sentiment_models = {}
-        self.vader_analyzer = None
-        self.max_model_retries = max_model_retries
-        self.cache = {}  # Simple cache for expensive operations
-        
-        # Influencers with validation
-        self.influencers = self._validate_influencers({
-            'elonmusk': {'name': 'Elon Musk', 'weight': 0.9, 'sector': 'all'},
-            'cz_binance': {'name': 'Changpeng Zhao', 'weight': 0.8, 'sector': 'crypto'},
-            'saylor': {'name': 'Michael Saylor', 'weight': 0.7, 'sector': 'bitcoin'},
-            'crypto_bitlord': {'name': 'Crypto Bitlord', 'weight': 0.6, 'sector': 'crypto'},
-            'aantonop': {'name': 'Andreas Antonopoulos', 'weight': 0.7, 'sector': 'bitcoin'},
-            'peterlbrandt': {'name': 'Peter Brandt', 'weight': 0.8, 'sector': 'trading'},
-            'nic__carter': {'name': 'Nic Carter', 'weight': 0.7, 'sector': 'crypto'},
-            'avalancheavax': {'name': 'Avalanche', 'weight': 0.6, 'sector': 'defi'}
-        })
-        
-        self._initialize_vader()
-    
-    def _validate_influencers(self, influencers: Dict) -> Dict:
-        """Validate and normalize influencer weights"""
-        validated = {}
-        total_weight = 0
-        
-        for username, data in influencers.items():
-            if 0.0 <= data.get('weight', 0) <= 1.0:
-                validated[username] = data
-                total_weight += data['weight']
-        
-        # Normalize weights to sum to 1
-        if total_weight > 0:
-            for username in validated:
-                validated[username]['weight'] /= total_weight
-        
-        logger.info(f"Validated {len(validated)} influencers with total weight {total_weight:.2f}")
-        return validated
-    
-    def _initialize_vader(self):
-        """Initialize VADER safely"""
-        try:
-            self.vader_analyzer = SentimentIntensityAnalyzer()
-            logger.info("VADER analyzer initialized")
-        except Exception as e:
-            logger.warning(f"Failed to initialize VADER: {e}")
-            self.vader_analyzer = None
-    
-    @lru_cache(maxsize=128)
-    def _safe_pipeline_load(self, model_name: str):
-        """Safely load pipeline with caching and retries"""
-        for attempt in range(self.max_model_retries):
-            try:
-                pipeline_obj = pipeline(
-                    "sentiment-analysis",
-                    model=model_name,
-                    tokenizer=model_name,
-                    device=-1,  # CPU only for stability
-                    return_all_scores=False
-                )
-                logger.info(f"Successfully loaded model: {model_name}")
-                return pipeline_obj
-            except Exception as e:
-                logger.warning(f"Attempt {attempt + 1} failed for {model_name}: {e}")
-                if attempt == self.max_model_retries - 1:
-                    return None
-                time.sleep(1)  # Brief delay before retry
-    
-    def initialize_models(self) -> bool:
-        """Initialize all sentiment analysis models with fallback"""
-        success_count = 0
-        
-        try:
-            # Financial sentiment model
-            financial_model = self._safe_pipeline_load(
-                "mrm8488/distilroberta-finetuned-financial-news-sentiment-analysis"
-            )
-            if financial_model:
-                self.sentiment_models['financial'] = financial_model
-                success_count += 1
-            
-            # General sentiment model with fallback
-            general_model = self._safe_pipeline_load("distilbert-base-uncased-finetuned-sst-2-english")
-            if general_model:
-                self.sentiment_models['general'] = general_model
-                success_count += 1
-            else:
-                # Fallback to basic pipeline
-                try:
-                    self.sentiment_models['general'] = pipeline("sentiment-analysis")
-                    success_count += 1
-                except:
-                    pass
-            
-            # Crypto-specific model with fallback
-            crypto_model = self._safe_pipeline_load("ElKulako/cryptobert")
-            if crypto_model:
-                self.sentiment_models['crypto'] = crypto_model
-                success_count += 1
-            else:
-                self.sentiment_models['crypto'] = self.sentiment_models.get('financial', 
-                                                                          self.sentiment_models.get('general'))
-                success_count += 1 if self.sentiment_models['crypto'] else 0
-            
-            # At least one model should be available
-            if success_count > 0:
-                logger.info(f"✅ Loaded {success_count} sentiment models successfully!")
-                return True
-            else:
-                logger.error("❌ No sentiment models could be loaded")
-                return False
-                
-        except Exception as e:
-            logger.error(f"❌ Critical error loading models: {e}")
-            return False
-    
-    def analyze_text_sentiment(self, text: str) -> Dict:
-        """Comprehensive sentiment analysis with robust error handling"""
-        if not text or len(text.strip()) < 5:
-            return self._default_sentiment()
-        
-        cache_key = hash(text.strip()[:100])  # Simple cache key
-        if cache_key in self.cache:
-            return self.cache[cache_key]
-        
-        try:
-            cleaned_text = self._clean_text(text)
-            
-            # Analyze with available models
-            model_results = []
-            
-            # Financial model
-            if 'financial' in self.sentiment_models:
-                model_results.append(self._analyze_model(cleaned_text, 'financial'))
-            
-            # General model
-            if 'general' in self.sentiment_models:
-                model_results.append(self._analyze_model(cleaned_text, 'general'))
-            
-            # Crypto model
-            if 'crypto' in self.sentiment_models:
-                model_results.append(self._analyze_model(cleaned_text, 'crypto'))
-            
-            # Rule-based models
-            if self.vader_analyzer:
-                model_results.append(self._analyze_vader(cleaned_text))
-            
-            model_results.append(self._analyze_textblob(cleaned_text))
-            
-            # Filter valid results
-            valid_results = [r for r in model_results if r['score'] is not None]
-            
-            if not valid_results:
-                return self._default_sentiment()
-            
-            # Weighted combination (prioritize financial/crypto models)
-            weights = {
-                'financial': 0.35, 'crypto': 0.30, 'general': 0.20,
-                'vader': 0.10, 'textblob': 0.05
-            }
-            
-            weighted_score = 0.0
-            total_weight = 0.0
-            confidences = []
-            
-            for result in valid_results:
-                model_type = result.get('model_type', 'unknown')
-                weight = weights.get(model_type, 0.1)
-                weighted_score += result['score'] * weight
-                total_weight += weight
-                if 'confidence' in result:
-                    confidences.append(result['confidence'])
-            
-            if total_weight > 0:
-                final_score = weighted_score / total_weight
-                final_confidence = np.mean(confidences) if confidences else 0.0
-            else:
-                final_score = 0.5
-                final_confidence = 0.0
-            
-            # Determine sentiment label
-            sentiment_label = self._score_to_label(final_score)
-            
-            result = {
-                "sentiment": sentiment_label,
-                "score": float(final_score),
-                "confidence": float(final_confidence),
-                "urgency": self._detect_urgency(cleaned_text),
-                "keywords": self._extract_keywords(cleaned_text),
-                "models_used": len(valid_results),
-                "text_snippet": cleaned_text[:100] + "..." if len(cleaned_text) > 100 else cleaned_text
-            }
-            
-            # Cache result
-            self.cache[cache_key] = result
-            if len(self.cache) > 50:  # Limit cache size
-                self.cache.pop(next(iter(self.cache)))
-            
-            return result
-            
-        except Exception as e:
-            logger.error(f"Error in sentiment analysis: {e}")
-            return self._default_sentiment()
-    
-    def _analyze_model(self, text: str, model_type: str) -> Dict:
-        """Generic model analysis with error handling"""
-        try:
-            model = self.sentiment_models[model_type]
-            result = model(text[:512], truncation=True, max_length=512)[0]  # Limit text length
-            
-            score_map = {
-                'negative': 0.0, 'NEGATIVE': 0.0,
-                'neutral': 0.5, 'NEUTRAL': 0.5,
-                'positive': 1.0, 'POSITIVE': 1.0
-            }
-            
-            score = score_map.get(result['label'].upper(), 0.5)
-            return {
-                'score': score,
-                'confidence': result['score'],
-                'model_type': model_type
-            }
-        except Exception as e:
-            logger.debug(f"Model {model_type} failed: {e}")
-            return {'score': None, 'confidence': 0.0, 'model_type': model_type}
-    
-    def _score_to_label(self, score: float) -> str:
-        """Convert score to sentiment label"""
-        if score > 0.6:
-            return "bullish"
-        elif score > 0.4:
-            return "neutral"
-        else:
-            return "bearish"
-    
-    def _analyze_vader(self, text: str) -> Dict:
-        """VADER analysis with error handling"""
-        if not self.vader_analyzer:
-            return {'score': None, 'confidence': 0.0, 'model_type': 'vader'}
-        
-        try:
-            scores = self.vader_analyzer.polarity_scores(text)
-            compound = (scores['compound'] + 1) / 2  # Normalize to 0-1
-            return {
-                'score': compound,
-                'confidence': abs(scores['compound']),
-                'model_type': 'vader'
-            }
-        except Exception:
-            return {'score': None, 'confidence': 0.0, 'model_type': 'vader'}
-    
-    def _analyze_textblob(self, text: str) -> Dict:
-        """TextBlob analysis with error handling"""
-        try:
-            analysis = TextBlob(text)
-            polarity = (analysis.sentiment.polarity + 1) / 2  # Normalize to 0-1
-            return {
-                'score': polarity,
-                'confidence': abs(analysis.sentiment.polarity),
-                'model_type': 'textblob'
-            }
-        except Exception:
-            return {'score': None, 'confidence': 0.0, 'model_type': 'textblob'}
-    
-    def _clean_text(self, text: str) -> str:
-        """Enhanced text cleaning"""
-        try:
-            # Remove URLs
-            text = re.sub(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', '', text)
-            # Remove mentions
-            text = re.sub(r'@\w+', '', text)
-            # Remove hashtags but keep text
-            text = re.sub(r'#\w+', '', text)
-            # Remove extra whitespace and normalize
-            text = ' '.join(text.split())
-            return text.strip()
-        except:
-            return text[:200] if len(text) > 200 else text
-    
-    def _extract_keywords(self, text: str) -> List[str]:
-        """Extract financial keywords with better matching"""
-        keyword_categories = {
-            'bullish': ['moon', 'rocket', 'bull', 'buy', 'long', 'growth', 'opportunity', 'bullrun'],
-            'bearish': ['crash', 'bear', 'sell', 'short', 'drop', 'dump', 'warning', 'risk', 'fud'],
-            'crypto': ['bitcoin', 'btc', 'ethereum', 'eth', 'crypto', 'blockchain', 'defi', 'nft'],
-            'urgency': ['now', 'urgent', 'immediately', 'alert', 'breaking', 'huge']
-        }
-        
-        found = []
-        text_lower = text.lower()
-        
-        for category, keywords in keyword_categories.items():
-            for keyword in keywords:
-                if re.search(rf'\b{keyword}\b', text_lower):
-                    found.append(f"{category}:{keyword}")
-        
-        return found[:5]
-    
-    def _detect_urgency(self, text: str) -> float:
-        """Improved urgency detection"""
-        urgency_indicators = ['!', 'urgent', 'breaking', 'alert', 'immediately', 'now', 'huge', 'massive']
-        text_lower = text.lower()
-        
-        score = 0.0
-        for indicator in urgency_indicators:
-            if re.search(rf'\b{indicator}\b', text_lower):
-                score += 0.15
-        
-        # Exclamation and question marks
-        punctuation_count = text.count('!') + text.count('?')
-        score += min(punctuation_count * 0.1, 0.3)
-        
-        # Caps lock indicator
-        caps_ratio = sum(1 for c in text if c.isupper()) / len([c for c in text if c.isalpha()])
-        score += min(caps_ratio * 0.5, 0.2)
-        
-        return min(score, 1.0)
-    
-    def _default_sentiment(self) -> Dict:
-        """Safe default sentiment"""
-        return {
-            "sentiment": "neutral",
-            "score": 0.5,
-            "confidence": 0.0,
-            "urgency": 0.0,
-            "keywords": [],
-            "models_used": 0,
-            "text_snippet": ""
-        }
-    
-    def get_influencer_sentiment(self, hours_back: int = 24) -> Dict:
-        """Get weighted influencer sentiment with caching"""
-        try:
-            # Generate synthetic tweets (in production, replace with real API)
-            tweets = self._generate_synthetic_tweets(hours_back)
-            influencer_sentiments = {}
-            
-            for username, tweet_batch in tweets.items():
-                if username not in self.influencers:
-                    continue
-                
-                tweet_sentiments = []
-                for tweet in tweet_batch:
-                    sentiment = self.analyze_text_sentiment(tweet['text'])
-                    sentiment.update({
-                        'timestamp': tweet['timestamp'],
-                        'username': username
-                    })
-                    tweet_sentiments.append(sentiment)
-                
-                if tweet_sentiments:
-                    # Weighted average by confidence
-                    total_weighted = sum(s['score'] * s['confidence'] for s in tweet_sentiments)
-                    total_confidence = sum(s['confidence'] for s in tweet_sentiments)
-                    
-                    avg_score = total_weighted / total_confidence if total_confidence > 0 else 0.5
-                    avg_confidence = np.mean([s['confidence'] for s in tweet_sentiments])
-                    
-                    influencer_sentiments[username] = {
-                        'score': float(avg_score),
-                        'confidence': float(avg_confidence),
-                        'weight': self.influencers[username]['weight'],
-                        'tweet_count': len(tweet_sentiments),
-                        'tweets': tweet_sentiments[:3]
-                    }
-            
-            # Calculate market sentiment
-            if influencer_sentiments:
-                total_weighted_score = sum(
-                    data['score'] * data['weight'] * data['confidence']
-                    for data in influencer_sentiments.values()
-                )
-                total_weight = sum(
-                    data['weight'] * data['confidence']
-                    for data in influencer_sentiments.values()
-                )
-                
-                market_sentiment = (total_weighted_score / total_weight 
-                                  if total_weight > 0 else 0.5)
-                avg_confidence = np.mean([d['confidence'] for d in influencer_sentiments.values()])
-            else:
-                market_sentiment = 0.5
-                avg_confidence = 0.0
-            
-            return {
-                "market_sentiment": float(market_sentiment),
-                "confidence": float(avg_confidence),
-                "influencer_count": len(influencer_sentiments),
-                "total_tweets": sum(d['tweet_count'] for d in influencer_sentiments.values()),
-                "timestamp": datetime.now().isoformat(),
-                "influencers": influencer_sentiments
-            }
-            
-        except Exception as e:
-            logger.error(f"Error in get_influencer_sentiment: {e}")
-            return {
-                "market_sentiment": 0.5,
-                "confidence": 0.0,
-                "error": str(e),
-                "timestamp": datetime.now().isoformat()
-            }
-    
-    def _generate_synthetic_tweets(self, hours_back: int) -> Dict:
-        """Generate realistic synthetic tweets for testing"""
-        current_time = time.time()
-        tweets = {}
-        np.random.seed(int(current_time) % 10000)  # Reproducible randomness
-        
-        # Simulate market conditions
-        market_trend = np.sin(current_time / 3600) * 0.3 + 0.5
-        
-        for username in self.influencers:
-            user_tweets = []
-            base_sentiment = np.clip(market_trend + np.random.normal(0, 0.15), 0.1, 0.9)
-            
-            templates = self._get_user_templates(username, base_sentiment)
-            
-            for i in range(np.random.randint(1, 4)):  # 1-3 tweets
-                template = np.random.choice(templates)
-                tweet_text = template.format(**self._get_template_vars(base_sentiment))
-                
-                # Add emojis occasionally
-                if np.random.random() < 0.4:
-                    emojis = self._get_relevant_emojis(base_sentiment)
-                    tweet_text += " " + np.random.choice(emojis)
-                
-                user_tweets.append({
-                    'text': tweet_text,
-                    'timestamp': current_time - (i * 3600 * np.random.uniform(0.5, hours_back))
-                })
-            
-            tweets[username] = user_tweets
-        
-        return tweets
-    
-    def _get_user_templates(self, username: str, sentiment: float) -> List[str]:
-        """Get appropriate templates based on sentiment"""
-        templates = {
-            'bullish': [
-                "{action} looking strong! {emoji}",
-                "Great {topic} developments ahead 🚀",
-                "Bullish on {topic} {emoji}"
-            ],
-            'bearish': [
-                "Caution on {topic} {emoji}",
-                "{action} facing challenges 📉",
-                "Bearish signals for {topic}"
-            ],
-            'neutral': [
-                "Watching {topic} developments 👀",
-                "{action} market update 📊",
-                "Interesting {topic} news"
-            ]
-        }
-        
-        category = 'bullish' if sentiment > 0.6 else 'bearish' if sentiment < 0.4 else 'neutral'
-        return templates[category]
-    
-    def _get_template_vars(self, sentiment: float) -> Dict:
-        """Get variables for tweet templates"""
-        topics = ['BTC', 'crypto', 'market', 'DeFi']
-        actions = ['Bitcoin', 'ETH', 'market', 'altcoins']
-        
-        return {
-            'topic': np.random.choice(topics),
-            'action': np.random.choice(actions),
-            'emoji': np.random.choice(['📈', '📉', '🚀', '💎'])
-        }
-    
-    def _get_relevant_emojis(self, sentiment: float) -> List[str]:
-        """Get sentiment-relevant emojis"""
-        if sentiment > 0.6:
-            return ['🚀', '📈', '💎', '🔥']
-        elif sentiment < 0.4:
-            return ['📉', '😬', '⚠️', '💥']
-        else:
-            return ['📊', '👀', '🤔', '💭']

src/utils/config.py

@@ -1,290 +0,0 @@
-import json
-import os
-from typing import Dict, Any, Optional
-from dataclasses import dataclass, asdict, field
-from pathlib import Path
-import logging
-
-logger = logging.getLogger(__name__)
-
-@dataclass
-class TradingConfig:
-    """Comprehensive trading configuration with validation and persistence"""
-    
-    # Environment settings
-    initial_balance: float = 10000.0
-    max_steps: int = 1000
-    transaction_cost: float = 0.001
-    risk_level: str = "Medium"
-    asset_type: str = "Crypto"
-    
-    # AI Agent settings
-    learning_rate: float = 0.001
-    gamma: float = 0.99
-    epsilon_start: float = 1.0
-    epsilon_min: float = 0.01
-    epsilon_decay: float = 0.9995
-    memory_size: int = 10000
-    batch_size: int = 32
-    target_update_freq: int = 100
-    gradient_clip: float = 1.0
-    
-    # Sentiment settings
-    use_sentiment: bool = True
-    sentiment_influence: float = 0.3
-    sentiment_update_freq: int = 5
-    
-    # Visualization settings
-    chart_width: int = 800
-    chart_height: int = 600
-    update_interval: int = 100
-    enable_visualization: bool = True
-    
-    # Training settings
-    max_episodes: int = 1000
-    eval_episodes: int = 10
-    eval_freq: int = 100
-    save_freq: int = 500
-    log_level: str = "INFO"
-    
-    # Paths
-    model_dir: str = "models"
-    log_dir: str = "logs"
-    data_dir: str = "data"
-    
-    # Device settings
-    use_cuda: bool = True
-    device: str = "auto"
-    
-    def __post_init__(self):
-        """Validate and initialize configuration"""
-        self._validate()
-        self._setup_paths()
-        self._setup_device()
-        self._setup_logging()
-    
-    def _validate(self):
-        """Validate configuration parameters"""
-        errors = []
-        
-        # Balance validation
-        if self.initial_balance <= 0:
-            errors.append("initial_balance must be positive")
-        
-        # Steps validation
-        if self.max_steps <= 0:
-            errors.append("max_steps must be positive")
-        
-        # Costs validation
-        if not 0.0 <= self.transaction_cost <= 0.1:
-            errors.append("transaction_cost should be between 0 and 0.1")
-        
-        # Learning rate validation
-        if not 0.0001 <= self.learning_rate <= 0.1:
-            errors.append("learning_rate should be between 0.0001 and 0.1")
-        
-        # Discount factor validation
-        if not 0.0 <= self.gamma <= 1.0:
-            errors.append("gamma must be between 0 and 1")
-        
-        # Epsilon validation
-        if not 0.0 <= self.epsilon_min <= self.epsilon_start <= 1.0:
-            errors.append("epsilon values must satisfy 0 <= epsilon_min <= epsilon_start <= 1")
-        
-        # Batch size validation
-        if self.batch_size > self.memory_size:
-            errors.append("batch_size cannot exceed memory_size")
-        
-        # Risk level validation
-        valid_risks = ["Low", "Medium", "High"]
-        if self.risk_level not in valid_risks:
-            errors.append(f"risk_level must be one of {valid_risks}")
-        
-        # Asset type validation
-        valid_assets = ["Crypto", "Stocks", "Forex", "Commodities"]
-        if self.asset_type not in valid_assets:
-            errors.append(f"asset_type must be one of {valid_assets}")
-        
-        # Sentiment influence validation
-        if not 0.0 <= self.sentiment_influence <= 1.0:
-            errors.append("sentiment_influence must be between 0 and 1")
-        
-        if errors:
-            logger.error(f"Configuration validation errors: {errors}")
-            raise ValueError(f"Invalid configuration: {'; '.join(errors)}")
-        
-        logger.info("Configuration validation passed")
-    
-    def _setup_paths(self):
-        """Create necessary directories"""
-        for path_attr in ['model_dir', 'log_dir', 'data_dir']:
-            path = Path(getattr(self, path_attr))
-            path.mkdir(parents=True, exist_ok=True)
-            setattr(self, f"{path_attr}_path", path)
-    
-    def _setup_device(self):
-        """Setup device configuration"""
-        import torch
-        if self.device == "auto":
-            self.device = "cuda" if self.use_cuda and torch.cuda.is_available() else "cpu"
-        else:
-            if self.device not in ["cpu", "cuda", "mps"]:
-                logger.warning(f"Unknown device {self.device}, defaulting to CPU")
-                self.device = "cpu"
-        
-        logger.info(f"Using device: {self.device}")
-    
-    def _setup_logging(self):
-        """Setup logging configuration"""
-        import logging
-        log_level = getattr(logging, self.log_level.upper())
-        logging.getLogger().setLevel(log_level)
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert config to dictionary, excluding sensitive paths"""
-        config_dict = asdict(self)
-        # Remove absolute paths for serialization
-        for key in list(config_dict.keys()):
-            if key.endswith('_path') or 'dir' in key:
-                config_dict[key] = str(getattr(self, key)) if isinstance(getattr(self, key), Path) else getattr(self, key)
-        return config_dict
-    
-    def to_json(self, filepath: Optional[str] = None) -> str:
-        """Serialize config to JSON"""
-        config_dict = self.to_dict()
-        json_str = json.dumps(config_dict, indent=2, default=str)
-        
-        if filepath:
-            with open(filepath, 'w') as f:
-                f.write(json_str)
-            logger.info(f"Config saved to {filepath}")
-        
-        return json_str
-    
-    @classmethod
-    def from_json(cls, filepath: str) -> 'TradingConfig':
-        """Load config from JSON file"""
-        try:
-            with open(filepath, 'r') as f:
-                config_dict = json.load(f)
-            
-            # Create dataclass instance
-            config = cls(**config_dict)
-            logger.info(f"Config loaded from {filepath}")
-            return config
-        except Exception as e:
-            logger.error(f"Error loading config from {filepath}: {e}")
-            raise
-    
-    @classmethod
-    def from_dict(cls, config_dict: Dict[str, Any]) -> 'TradingConfig':
-        """Create config from dictionary"""
-        return cls(**config_dict)
-    
-    def save(self, filepath: str):
-        """Save config to file"""
-        self.to_json(filepath)
-    
-    @staticmethod
-    def load(filepath: str) -> 'TradingConfig':
-        """Static method to load config"""
-        return TradingConfig.from_json(filepath)
-    
-    def update(self, **kwargs):
-        """Update config parameters and revalidate"""
-        for key, value in kwargs.items():
-            if hasattr(self, key):
-                setattr(self, key, value)
-            else:
-                logger.warning(f"Unknown config parameter: {key}")
-        
-        self._validate()
-        logger.info("Config updated and validated")
-    
-    def get_agent_params(self) -> Dict[str, Any]:
-        """Get parameters specific to agent"""
-        return {
-            'learning_rate': self.learning_rate,
-            'gamma': self.gamma,
-            'epsilon_start': self.epsilon_start,
-            'epsilon_min': self.epsilon_min,
-            'epsilon_decay': self.epsilon_decay,
-            'memory_size': self.memory_size,
-            'batch_size': self.batch_size,
-            'target_update_freq': self.target_update_freq,
-            'gradient_clip': self.gradient_clip,
-            'device': self.device
-        }
-    
-    def get_env_params(self) -> Dict[str, Any]:
-        """Get parameters specific to environment"""
-        return {
-            'initial_balance': self.initial_balance,
-            'max_steps': self.max_steps,
-            'transaction_cost': self.transaction_cost,
-            'risk_level': self.risk_level,
-            'asset_type': self.asset_type,
-            'use_sentiment': self.use_sentiment,
-            'sentiment_influence': self.sentiment_influence,
-            'sentiment_update_freq': self.sentiment_update_freq
-        }
-    
-    def __str__(self) -> str:
-        """String representation of config"""
-        return json.dumps(self.to_dict(), indent=2)
-
-
-# Legacy compatibility
-class LegacyTradingConfig:
-    """Wrapper for backward compatibility"""
-    
-    def __init__(self, config_file: Optional[str] = None):
-        if config_file and os.path.exists(config_file):
-            self.config = TradingConfig.from_json(config_file)
-        else:
-            self.config = TradingConfig()
-    
-    def __getattr__(self, name):
-        return getattr(self.config, name)
-    
-    def to_dict(self):
-        return self.config.to_dict()
-
-
-# Default config instance
-DEFAULT_CONFIG = TradingConfig()
-
-# Example usage and config loading
-def create_config_from_env() -> TradingConfig:
-    """Create config from environment variables"""
-    import os
-    config_dict = {}
-    
-    env_mappings = {
-        'INITIAL_BALANCE': 'initial_balance',
-        'MAX_STEPS': 'max_steps',
-        'LEARNING_RATE': 'learning_rate',
-        'BATCH_SIZE': 'batch_size',
-        'USE_CUDA': 'use_cuda'
-    }
-    
-    for env_var, config_key in env_mappings.items():
-        env_value = os.getenv(env_var)
-        if env_value is not None:
-            try:
-                # Try to convert to appropriate type
-                if config_key in ['initial_balance', 'learning_rate']:
-                    config_dict[config_key] = float(env_value)
-                elif config_key in ['max_steps', 'batch_size']:
-                    config_dict[config_key] = int(env_value)
-                elif config_key == 'use_cuda':
-                    config_dict[config_key] = env_value.lower() in ('true', '1', 'yes')
-            except ValueError:
-                logger.warning(f"Invalid environment variable {env_var}: {env_value}")
-    
-    if config_dict:
-        base_config = TradingConfig()
-        base_config.update(**config_dict)
-        return base_config
-    
-    return DEFAULT_CONFIG

src/visualizers/chart_renderer.py

@@ -1,410 +0,0 @@
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import plotly.express as px
-import numpy as np
-import pandas as pd
-from typing import List, Dict, Any, Optional, Union
-import logging
-from datetime import datetime
-import warnings
-warnings.filterwarnings('ignore')
-
-logger = logging.getLogger(__name__)
-
-class ChartRenderer:
-    """Advanced chart renderer for trading visualizations with error handling"""
-    
-    def __init__(self, theme: str = "plotly_white", default_height: int = 400):
-        self.theme = theme
-        self.default_height = default_height
-        self._validate_plotly()
-    
-    def _validate_plotly(self):
-        """Validate Plotly installation and capabilities"""
-        try:
-            import plotly
-            logger.info(f"Plotly version: {plotly.__version__}")
-        except ImportError:
-            raise ImportError("Plotly is required for ChartRenderer")
-    
-    def _safe_data_validation(self, data, expected_len: Optional[int] = None, 
-                            data_type: str = "data") -> bool:
-        """Validate input data safely"""
-        if data is None or len(data) == 0:
-            logger.warning(f"No {data_type} provided")
-            return False
-        
-        if expected_len and len(data) != expected_len:
-            logger.warning(f"{data_type} length mismatch: expected {expected_len}, got {len(data)}")
-        
-        if isinstance(data, (list, np.ndarray)):
-            if np.any(np.isnan(data)) or np.any(np.isinf(data)):
-                logger.warning(f"{data_type} contains NaN or Inf values")
-                return False
-        
-        return True
-    
-    def render_price_chart(self, prices: Union[List[float], np.ndarray], 
-                         actions: Optional[List[int]] = None, 
-                         current_step: int = 0,
-                         title: Optional[str] = None,
-                         height: Optional[int] = None) -> go.Figure:
-        """Render interactive price chart with trading actions"""
-        fig = go.Figure()
-        height = height or self.default_height
-        
-        # Validate data
-        if not self._safe_data_validation(prices, data_type="prices"):
-            return self._create_empty_figure("No Price Data", height)
-        
-        try:
-            # Convert to numpy for consistency
-            prices = np.array(prices, dtype=np.float64)
-            time_steps = np.arange(len(prices))
-            
-            # Add main price trace
-            fig.add_trace(go.Scatter(
-                x=time_steps,
-                y=prices,
-                mode='lines',
-                name='Price',
-                line=dict(color='#1f77b4', width=2),
-                hovertemplate='<b>Step %{x}</b><br>Price: $%{y:.2f}<extra></extra>'
-            ))
-            
-            # Add action markers with validation
-            if actions and self._safe_data_validation(actions, len(prices), "actions"):
-                self._add_action_markers(fig, prices, actions, time_steps)
-            
-            # Add current step indicator
-            if 0 <= current_step < len(prices):
-                fig.add_vline(
-                    x=current_step,
-                    line_dash="dash",
-                    line_color="orange",
-                    annotation_text=f"Current Step ({current_step})",
-                    annotation_position="top right"
-                )
-            
-            # Calculate and add key metrics
-            self._add_price_metrics(fig, prices)
-            
-            title = title or f"Asset Price Evolution (Step: {current_step})"
-            fig.update_layout(
-                title={
-                    'text': title,
-                    'x': 0.5,
-                    'xanchor': 'center',
-                    'font': {'size': 16}
-                },
-                xaxis_title="Time Step",
-                yaxis_title="Price ($)",
-                height=height + 100,
-                showlegend=True,
-                template=self.theme,
-                hovermode='x unified'
-            )
-            
-            fig.update_xaxes(showgrid=True, gridwidth=1, gridcolor='lightgray')
-            fig.update_yaxes(showgrid=True, gridwidth=1, gridcolor='lightgray')
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Error rendering price chart: {e}")
-            return self._create_empty_figure("Error Rendering Price Chart", height)
-    
-    def _add_action_markers(self, fig: go.Figure, prices: np.ndarray, 
-                          actions: List[int], time_steps: np.ndarray):
-        """Add buy/sell/close action markers to figure"""
-        action_configs = {
-            1: {'name': 'Buy', 'color': '#2ca02c', 'symbol': 'triangle-up'},
-            2: {'name': 'Sell', 'color': '#d62728', 'symbol': 'triangle-down'},
-            3: {'name': 'Close', 'color': '#ff7f0e', 'symbol': 'x'}
-        }
-        
-        for action_id, config in action_configs.items():
-            indices = [i for i, a in enumerate(actions) if a == action_id]
-            if indices:
-                action_prices = prices[indices]
-                fig.add_trace(go.Scatter(
-                    x=[time_steps[i] for i in indices],
-                    y=action_prices,
-                    mode='markers',
-                    name=config['name'],
-                    marker=dict(
-                        color=config['color'],
-                        size=12,
-                        symbol=config['symbol'],
-                        line=dict(width=2, color='white')
-                    ),
-                    hovertemplate=f'<b>{config["name"]}</b><br>Step: %{{x}}<br>Price: $%{{y:.2f}}<extra></extra>',
-                    showlegend=True
-                ))
-    
-    def _add_price_metrics(self, fig: go.Figure, prices: np.ndarray):
-        """Add price statistics as annotations"""
-        if len(prices) < 2:
-            return
-        
-        max_price = np.max(prices)
-        min_price = np.min(prices)
-        avg_price = np.mean(prices)
-        
-        # Add horizontal reference lines
-        fig.add_hline(y=max_price, line_dash="dot", line_color="green",
-                     annotation_text=f"Max: ${max_price:.2f}")
-        fig.add_hline(y=min_price, line_dash="dot", line_color="red",
-                     annotation_text=f"Min: ${min_price:.2f}")
-        fig.add_hline(y=avg_price, line_dash="dash", line_color="blue",
-                     annotation_text=f"Avg: ${avg_price:.2f}")
-    
-    def create_performance_chart(self, net_worth_history: List[float], 
-                               reward_history: Optional[List[float]] = None,
-                               initial_balance: float = 10000,
-                               height: Optional[int] = None) -> go.Figure:
-        """Create comprehensive performance dashboard"""
-        height = height or 600
-        
-        if not self._safe_data_validation(net_worth_history, data_type="net worth history"):
-            return self._create_empty_figure("No Performance Data", height)
-        
-        try:
-            fig = make_subplots(
-                rows=2, cols=2,
-                subplot_titles=['Portfolio Value', 'Returns vs Initial Balance', 
-                              'Cumulative Reward', 'Reward Distribution'],
-                vertical_spacing=0.1,
-                horizontal_spacing=0.1,
-                specs=[[{"secondary_y": False}, {"secondary_y": False}],
-                      [{"secondary_y": False}, {"secondary_y": False}]]
-            )
-            
-            steps = np.arange(len(net_worth_history))
-            net_worth = np.array(net_worth_history)
-            
-            # Portfolio value
-            fig.add_trace(
-                go.Scatter(x=steps, y=net_worth, mode='lines', name='Net Worth',
-                         line=dict(color='#2ca02c', width=3)),
-                row=1, col=1
-            )
-            
-            # Initial balance reference
-            fig.add_hline(y=initial_balance, line_dash="dash", line_color="red",
-                         annotation_text=f"Initial: ${initial_balance:.2f}",
-                         row=1, col=1)
-            
-            # Returns comparison
-            returns = (net_worth - initial_balance) / initial_balance * 100
-            fig.add_trace(
-                go.Scatter(x=steps, y=returns, mode='lines', name='Returns %',
-                         line=dict(color='#ff7f0e', width=2)),
-                row=1, col=2
-            )
-            fig.add_hline(y=0, line_dash="solid", line_color="gray", row=1, col=2)
-            
-            # Cumulative reward
-            if reward_history and self._safe_data_validation(reward_history):
-                cum_reward = np.cumsum(reward_history)
-                fig.add_trace(
-                    go.Scatter(x=steps[:len(cum_reward)], y=cum_reward, mode='lines',
-                             name='Cumulative Reward', line=dict(color='#9467bd', width=2)),
-                    row=2, col=1
-                )
-            
-            # Reward distribution
-            if reward_history:
-                fig.add_trace(
-                    go.Histogram(x=reward_history, name='Reward Distribution',
-                               marker_color='#1f77b4', opacity=0.7),
-                    row=2, col=2
-                )
-            
-            fig.update_layout(
-                height=height,
-                showlegend=True,
-                title_text="Trading Performance Dashboard",
-                template=self.theme
-            )
-            
-            # Update axis titles
-            fig.update_yaxes(title_text="Value ($)", row=1, col=1)
-            fig.update_yaxes(title_text="Returns (%)", row=1, col=2)
-            fig.update_yaxes(title_text="Cumulative Reward", row=2, col=1)
-            fig.update_xaxes(title_text="Steps", row=2, col=1)
-            fig.update_xaxes(title_text="Reward Value", row=2, col=2)
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Error creating performance chart: {e}")
-            return self._create_empty_figure("Error in Performance Chart", height)
-    
-    def create_action_distribution(self, actions: List[int], 
-                                 title: Optional[str] = None,
-                                 height: Optional[int] = None) -> go.Figure:
-        """Create interactive action distribution visualization"""
-        height = height or 350
-        
-        if not self._safe_data_validation(actions, data_type="actions"):
-            return self._create_empty_figure("No Actions Data", height)
-        
-        try:
-            action_names = ['Hold', 'Buy', 'Sell', 'Close']
-            action_counts = [actions.count(i) for i in range(4)]
-            total_actions = sum(action_counts)
-            
-            colors = ['#1f77b4', '#2ca02c', '#d62728', '#ff7f0e']
-            
-            fig = go.Figure(data=[go.Pie(
-                labels=action_names,
-                values=action_counts,
-                hole=0.4,
-                marker_colors=colors,
-                textinfo='label+percent+value',
-                hovertemplate='<b>%{label}</b><br>Count: %{value}<br>Percentage: %{percent}<extra></extra>',
-                pull=[0, 0, 0, 0]  # Equal spacing
-            )])
-            
-            title = title or f"Action Distribution (Total: {total_actions} actions)"
-            fig.update_layout(
-                title={
-                    'text': title,
-                    'x': 0.5,
-                    'xanchor': 'center'
-                },
-                height=height,
-                showlegend=True,
-                template=self.theme,
-                annotations=[dict(
-                    text='Trading Actions',
-                    x=0.5, y=0.5,
-                    font_size=16,
-                    showarrow=False
-                )]
-            )
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Error creating action distribution: {e}")
-            return self._create_empty_figure("Error in Action Distribution", height)
-    
-    def create_training_progress(self, training_history: List[Dict], 
-                               window_size: int = 10,
-                               height: Optional[int] = None) -> go.Figure:
-        """Create comprehensive training progress dashboard"""
-        height = height or 700
-        
-        if not training_history:
-            return self._create_empty_figure("No Training Data", height)
-        
-        try:
-            # Extract data safely
-            episodes = [h.get('episode', i) for i, h in enumerate(training_history)]
-            rewards = [h.get('reward', 0) for h in training_history]
-            net_worths = [h.get('net_worth', 0) for h in training_history]
-            losses = [h.get('loss', 0) for h in training_history]
-            
-            fig = make_subplots(
-                rows=2, cols=2,
-                subplot_titles=['Total Reward per Episode', 'Final Net Worth',
-                              'Training Loss', 'Moving Average Reward'],
-                specs=[[{"secondary_y": False}, {"secondary_y": False}],
-                      [{"secondary_y": False}, {"secondary_y": False}]]
-            )
-            
-            # Rewards
-            fig.add_trace(go.Scatter(
-                x=episodes, y=rewards, mode='lines+markers',
-                name='Episode Reward', line=dict(color='#1f77b4', width=2),
-                marker=dict(size=4)
-            ), row=1, col=1)
-            
-            # Net worth
-            fig.add_trace(go.Scatter(
-                x=episodes, y=net_worths, mode='lines+markers',
-                name='Final Net Worth', line=dict(color='#2ca02c', width=2),
-                marker=dict(size=4)
-            ), row=1, col=2)
-            
-            # Loss (only if we have meaningful loss values)
-            valid_losses = [l for l in losses if l > 0]
-            if valid_losses:
-                fig.add_trace(go.Scatter(
-                    x=episodes, y=losses, mode='lines',
-                    name='Training Loss', line=dict(color='#d62728', width=2)
-                ), row=2, col=1)
-            
-            # Moving average
-            if len(rewards) >= window_size:
-                ma_rewards = pd.Series(rewards).rolling(window=window_size, min_periods=1).mean()
-                fig.add_trace(go.Scatter(
-                    x=episodes, y=ma_rewards, mode='lines',
-                    name=f'MA Reward ({window_size})', 
-                    line=dict(color='#ff7f0e', width=3, dash='dash')
-                ), row=2, col=2)
-            
-            fig.update_layout(
-                height=height,
-                showlegend=True,
-                title_text=f"Training Progress - {len(episodes)} Episodes",
-                template=self.theme
-            )
-            
-            # Update axes
-            fig.update_yaxes(title_text="Reward", row=1, col=1)
-            fig.update_yaxes(title_text="Net Worth ($)", row=1, col=2)
-            fig.update_yaxes(title_text="Loss", row=2, col=1)
-            fig.update_xaxes(title_text="Episodes", row=2, col=1)
-            
-            return fig
-            
-        except Exception as e:
-            logger.error(f"Error creating training progress chart: {e}")
-            return self._create_empty_figure("Error in Training Progress", height)
-    
-    def _create_empty_figure(self, title: str, height: int) -> go.Figure:
-        """Create a safe empty figure"""
-        fig = go.Figure()
-        fig.update_layout(
-            title=title,
-            height=height,
-            template=self.theme
-        )
-        return fig
-    
-    def save_chart(self, fig: go.Figure, filename: str, format: str = 'html'):
-        """Save chart to file"""
-        try:
-            if format == 'html':
-                fig.write_html(filename)
-            elif format == 'png':
-                fig.write_image(filename)
-            elif format == 'pdf':
-                fig.write_image(filename, width=1200, height=800)
-            logger.info(f"Chart saved as {filename}")
-        except Exception as e:
-            logger.error(f"Error saving chart: {e}")
-    
-    def show(self, fig: go.Figure):
-        """Display chart (if in interactive environment)"""
-        try:
-            fig.show()
-        except Exception as e:
-            logger.warning(f"Could not display chart: {e}")
-
-
-# Utility functions for batch rendering
-def render_dashboard(prices, actions, net_worth, rewards, config):
-    """Create a complete trading dashboard"""
-    renderer = ChartRenderer()
-    
-    figs = {
-        'price': renderer.render_price_chart(prices, actions),
-        'performance': renderer.create_performance_chart(net_worth, rewards, config.initial_balance),
-        'actions': renderer.create_action_distribution(actions)
-    }
-    
-    return figs