Update app.py

app.py

@@ -1,957 +1,337 @@
-"""
-Advanced AI Trading Demo - Hugging Face Spaces
-Deep Q-Network (DQN) Reinforcement Learning for Financial Trading Simulation
-
-Author: AI Trading Team
-License: MIT
-"""
-
 import gradio as gr
+import pandas as pd
 import numpy as np
-import torch
-import torch.nn as nn
-import torch.optim as optim
-from collections import deque
-import random
-from typing import Dict, Tuple, Any, List, Optional, Generator
+import yfinance as yf
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
-import logging
-import os
-from datetime import datetime
-import json
-from dataclasses import dataclass  # ✅ Added missing import
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# ---- 1. Enhanced Configuration ----
-@dataclass
-class TradingConfig:
-    """Central configuration for trading environment and agent."""
-    
-    # Financial Parameters
-    initial_balance: float = 10000.0
-    max_steps: int = 1000
-    transaction_cost: float = 0.001  # 0.1%
-    
-    # Asset Settings
-    asset_type: str = "Crypto"
-    risk_level: str = "Medium"
-    
-    # DQN Parameters
-    learning_rate: float = 0.0001
-    gamma: float = 0.99
-    epsilon_start: float = 1.0
-    epsilon_min: float = 0.01
-    epsilon_decay: float = 0.9995
-    batch_size: int = 32
-    memory_size: int = 10000
-    target_update: int = 100
-    hidden_size: int = 128
-    
-    # Risk Management
-    risk_multipliers: Dict[str, float] = None
-    
-    def __post_init__(self):
-        if self.risk_multipliers is None:
-            self.risk_multipliers = {
-                "Low": 0.5,
-                "Medium": 1.0,
-                "High": 2.0
-            }
-        
-        # Asset-specific volatility
-        self.volatility_map = {
-            "Crypto": 0.03,
-            "Stock": 0.015,
-            "Forex": 0.008
-        }
+from datetime import datetime, timedelta
+import warnings
+warnings.filterwarnings('ignore')
 
-# ---- 2. Professional Trading Environment ----
-class AdvancedTradingEnvironment:
-    """
-    Realistic financial market simulator with multi-asset support,
-    technical indicators, sentiment analysis, and risk management.
-    """
-    
-    def __init__(self, config: TradingConfig):
-        self.config = config
-        self._reset_state()
-        self._initialize_market_data()
-        
-        # Action space: 0=Hold, 1=Buy, 2=Sell, 3=Close
-        self.action_space = 4
-        self.observation_space_dim = 15
+# Market Data Provider
+class MarketDataProvider:
+    def __init__(self, symbols=['AAPL', 'GOOGL', 'MSFT', 'TSLA']):
+        self.symbols = symbols
+        self.data_cache = {}
         
-        # Tracking
-        self.portfolio_history = []
-        self.action_history = []
-        self.trade_log = []
-        
-    def _reset_state(self):
-        """Reset internal state to initial conditions."""
-        self.balance = self.config.initial_balance
-        self.position = 0.0
-        self.current_price = 100.0
-        self.step_count = 0
-        self.portfolio_history = []
-        self.action_history = []
-        self.trade_log = []
-        
-    def _initialize_market_data(self):
-        """Generate initial market data with realistic dynamics."""
-        n_points = 200
-        volatility = self.config.volatility_map.get(
-            self.config.asset_type, 0.02
-        )
-        
-        self.price_history = []
-        self.volume_history = []
-        self.sentiment_history = []
-        
-        base_price = 100.0
-        for i in range(n_points):
-            # Generate price with momentum and noise
-            momentum = np.sin(i * 0.05) * 2
-            noise = np.random.normal(0, volatility)
-            price = base_price * (1 + momentum * 0.01 + noise)
-            self.price_history.append(max(10.0, price))
+    def get_stock_data(self, symbol, period='1mo'):
+        try:
+            cache_key = f"{symbol}_{period}"
+            if cache_key in self.data_cache:
+                return self.data_cache[cache_key]
             
-            # Volume correlated with price movement
-            volume = 1000 + abs(price - base_price) * 50 + np.random.normal(0, 200)
-            self.volume_history.append(max(100, volume))
+            ticker = yf.Ticker(symbol)
+            hist_data = ticker.history(period=period)
             
-            # Sentiment with mean reversion
-            if i > 0:
-                prev_sentiment = self.sentiment_history[-1]
-                sentiment_change = np.random.normal(0, 0.08)
-                sentiment = prev_sentiment + sentiment_change
-            else:
-                sentiment = 0.5 + np.random.normal(0, 0.1)
-            self.sentiment_history.append(np.clip(sentiment, 0.0, 1.0))
+            if hist_data.empty:
+                return self.generate_simulated_data(symbol)
             
-        self.current_price = self.price_history[-1]
-    
-    def _calculate_technical_indicators(self) -> List[float]:
-        """Compute comprehensive technical indicators."""
-        prices = np.array(self.price_history[-50:])
-        if len(prices) < 2:
-            return [0.0] * 6
+            data = {
+                'prices': hist_data['Close'].tolist(),
+                'dates': hist_data.index.strftime('%Y-%m-%d').tolist(),
+                'volume': hist_data['Volume'].tolist(),
+                'current_price': hist_data['Close'].iloc[-1],
+                'change': ((hist_data['Close'].iloc[-1] - hist_data['Close'].iloc[0]) / hist_data['Close'].iloc[0]) * 100
+            }
             
-        # Price returns
-        returns = np.diff(prices) / prices[:-1]
-        
-        # Moving averages
-        sma_short = np.mean(prices[-10:]) if len(prices) >= 10 else prices[-1]
-        sma_long = np.mean(prices[-20:]) if len(prices) >= 20 else prices[-1]
-        
-        # RSI
-        if len(returns) >= 14:
-            gains = returns[returns > 0]
-            losses = -returns[returns < 0]
-            avg_gain = np.mean(gains[-14:]) if len(gains) > 0 else 0.001
-            avg_loss = np.mean(losses[-14:]) if len(losses) > 0 else 0.001
-            rs = avg_gain / avg_loss if avg_loss != 0 else 100
-            rsi = 100 - (100 / (1 + rs))
-        else:
-            rsi = 50.0
+            self.data_cache[cache_key] = data
+            return data
             
-        # Volatility and momentum
-        volatility = np.std(returns) * np.sqrt(252) if len(returns) > 1 else 0.1
-        momentum = (prices[-1] / prices[-5] - 1) if len(prices) >= 5 else 0.0
-        
-        # Volume trend
-        volumes = np.array(self.volume_history[-10:])
-        volume_trend = (np.mean(volumes[-5:]) / np.mean(volumes[-10:]) - 1 
-                       if len(volumes) >= 10 else 0.0)
-        
-        # Normalize features
-        return [
-            sma_short / 100.0,
-            sma_long / 100.0,
-            rsi / 100.0,
-            volatility,
-            momentum,
-            volume_trend
-        ]
-    
-    def reset(self) -> Tuple[np.ndarray, Dict]:
-        """Reset environment to initial state."""
-        self._reset_state()
-        self._initialize_market_data()  # ✅ Reinitialize market data on reset
-        obs = self._get_observation()
-        info = self._get_info()
-        return obs, info
+        except Exception as e:
+            print(f"Error fetching {symbol}: {e}")
+            return self.generate_simulated_data(symbol)
     
-    def step(self, action: int) -> Tuple[np.ndarray, float, bool, bool, Dict]:
-        """Execute one step in the environment."""
-        self.step_count += 1
-        self._update_market_data()
-        reward = self._execute_action(action)
+    def generate_simulated_data(self, symbol):
+        base_price = np.random.uniform(100, 200)
+        days = 30
+        prices = [base_price * (1 + np.random.normal(0, 0.02)) for _ in range(days)]
+        dates = [(datetime.now() - timedelta(days=i)).strftime('%Y-%m-%d') for i in range(days, 0, -1)]
         
-        terminated = (self.balance <= 0 or 
-                     self.step_count >= self.config.max_steps)
-        truncated = False
+        return {
+            'prices': prices,
+            'dates': dates,
+            'volume': [np.random.randint(1000000, 5000000) for _ in range(days)],
+            'current_price': prices[-1],
+            'change': ((prices[-1] - prices[0]) / prices[0]) * 100
+        }
+
+# AI Trading Agents
+class TradingAgents:
+    def __init__(self):
+        self.agents_config = {
+            'research': {
+                'name': 'Financial Research Agent',
+                'emoji': '📊',
+                'prompt_template': """Analyze {symbol} stock:
+Price: ${current_price:.2f}
+Change: {change:+.2f}%
+Trend: {trend}
+
+Provide fundamental analysis and recommendation:"""
+            },
+            'technical': {
+                'name': 'Technical Analysis Agent', 
+                'emoji': '📈',
+                'prompt_template': """Technical analysis for {symbol}:
+Price: ${current_price:.2f}
+Trend: {trend}
+Volatility: {volatility:.1f}%
+
+Provide technical levels and trading signals:"""
+            },
+            'risk': {
+                'name': 'Risk Management Agent',
+                'emoji': '🛡️',
+                'prompt_template': """Risk assessment for {symbol}:
+Price: ${current_price:.2f}
+Volatility: {volatility:.1f}%
+
+Provide risk management strategy:"""
+            }
+        }
         
-        obs = self._get_observation()
-        info = self._get_info()
+    def calculate_metrics(self, price_data):
+        prices = price_data['prices']
+        if len(prices) < 2:
+            return {"trend": "Neutral", "volatility": 0}
         
-        self.portfolio_history.append(info['net_worth'])
-        self.action_history.append(action)
+        price_change = ((prices[-1] - prices[0]) / prices[0]) * 100
+        returns = np.diff(prices) / prices[:-1]
+        volatility = np.std(returns) * np.sqrt(252) * 100
         
-        return obs, reward, terminated, truncated, info
-    
-    def _update_market_data(self):
-        """Update market data with realistic dynamics."""
-        # Momentum from recent returns
-        recent_prices = self.price_history[-5:]
-        if len(recent_prices) >= 2:
-            prev_returns = np.diff(recent_prices) / recent_prices[:-1]
-            momentum = np.mean(prev_returns)
+        if price_change > 5:
+            trend = "Strong Bullish"
+        elif price_change > 0:
+            trend = "Mild Bullish" 
         else:
-            momentum = 0
-            
-        # Asset-specific volatility with risk multiplier
-        base_vol = self.config.volatility_map.get(self.config.asset_type, 0.015)
-        volatility = base_vol * self.config.risk_multipliers[self.config.risk_level]
-        
-        # Price evolution
-        price_change = momentum * 0.3 + np.random.normal(0, volatility)
-        self.current_price = max(10.0, self.current_price * (1 + price_change))
-        self.price_history.append(self.current_price)
-        
-        # Volume generation
-        base_volume = 1000
-        volume_noise = np.random.normal(0, 200)
-        new_volume = max(100, base_volume + abs(price_change) * 5000 + volume_noise)
-        self.volume_history.append(new_volume)
+            trend = "Bearish"
         
-        # Sentiment with mean reversion
-        current_sentiment = self.sentiment_history[-1]
-        sentiment_reversion = (0.5 - current_sentiment) * 0.1
-        sentiment_noise = np.random.normal(0, 0.08)
-        new_sentiment = np.clip(current_sentiment + sentiment_reversion + sentiment_noise, 0.0, 1.0)
-        self.sentiment_history.append(new_sentiment)
+        return {
+            "trend": f"{trend} ({price_change:+.1f}%)",
+            "volatility": volatility,
+            "price_change": price_change
+        }
     
-    def _execute_action(self, action: int) -> float:
-        """Execute trading action and calculate reward."""
-        prev_net_worth = self.balance + self.position * self.current_price
-        
-        # Risk-adjusted position sizing
-        trade_size_multiplier = 0.2 * self.config.risk_multipliers[self.config.risk_level]
-        
-        if action == 1:  # Buy
-            if self.balance > 0:
-                trade_amount = min(self.balance * trade_size_multiplier, self.balance)
-                cost = trade_amount * (1 + self.config.transaction_cost)
-                if cost <= self.balance:
-                    shares_bought = trade_amount / self.current_price
-                    self.position += shares_bought
-                    self.balance -= cost
-                    self.trade_log.append({
-                        'type': 'BUY',
-                        'shares': shares_bought,
-                        'price': self.current_price,
-                        'timestamp': self.step_count
-                    })
-                    
-        elif action == 2:  # Sell
-            if self.position > 0:
-                sell_fraction = trade_size_multiplier
-                shares_to_sell = min(self.position * sell_fraction, self.position)
-                proceeds = shares_to_sell * self.current_price * (1 - self.config.transaction_cost)
-                self.position -= shares_to_sell
-                self.balance += proceeds
-                self.trade_log.append({
-                    'type': 'SELL',
-                    'shares': shares_to_sell,
-                    'price': self.current_price,
-                    'timestamp': self.step_count
-                })
-                
-        elif action == 3:  # Close Position
-            if self.position > 0:
-                proceeds = self.position * self.current_price * (1 - self.config.transaction_cost)
-                self.balance += proceeds
-                self.trade_log.append({
-                    'type': 'CLOSE',
-                    'shares': self.position,
-                    'price': self.current_price,
-                    'timestamp': self.step_count
-                })
-                self.position = 0
-        
-        # Reward calculation with risk management
-        new_net_worth = self.balance + self.position * self.current_price
-        raw_reward = (new_net_worth - prev_net_worth) / self.config.initial_balance * 100
-        
-        # Risk penalty for significant drawdowns
-        risk_penalty = 0.0
-        if new_net_worth < self.config.initial_balance * 0.8:
-            risk_penalty = (self.config.initial_balance - new_net_worth) / self.config.initial_balance * 10
+    def analyze_stock(self, symbol, price_data):
+        metrics = self.calculate_metrics(price_data)
+        current_price = price_data['current_price']
+        
+        analyses = {}
+        
+        for agent_type, config in self.agents_config.items():
+            prompt = config['prompt_template'].format(
+                symbol=symbol,
+                current_price=current_price,
+                change=metrics['price_change'],
+                trend=metrics['trend'],
+                volatility=metrics['volatility']
+            )
             
-        final_reward = raw_reward - risk_penalty
-        return final_reward
-    
-    def _get_observation(self) -> np.ndarray:
-        """Generate observation vector for the agent."""
-        # Price features
-        recent_prices = (self.price_history[-20:] if len(self.price_history) >= 20 
-                        else [self.current_price] * 20)
-        price_features = [
-            self.current_price / 100.0,
-            np.mean(recent_prices) / 100.0,
-            np.std(recent_prices) / 100.0,
-            (self.current_price - np.min(recent_prices)) / 
-            (np.max(recent_prices) - np.min(recent_prices) + 1e-8)
-        ]
-        
-        # Portfolio features
-        portfolio_features = [
-            self.balance / self.config.initial_balance,
-            (self.position * self.current_price) / self.config.initial_balance,
-            self.step_count / self.config.max_steps
-        ]
-        
-        # Sentiment features
-        recent_sentiments = (self.sentiment_history[-10:] if len(self.sentiment_history) >= 10 
-                           else [0.5] * 10)
-        sentiment_features = [
-            np.mean(recent_sentiments),
-            np.std(recent_sentiments),
-            recent_sentiments[-1]
-        ]
+            analysis = self.get_agent_response(agent_type, prompt)
+            analyses[agent_type] = {
+                'name': config['name'],
+                'emoji': config['emoji'],
+                'analysis': analysis
+            }
         
-        # Technical indicators
-        technical_features = self._calculate_technical_indicators()
+        analyses['decision'] = self.generate_final_decision(symbol, current_price, analyses, metrics)
+        return analyses
+    
+    def get_agent_response(self, agent_type, prompt):
+        responses = {
+            'research': [
+                "📊 STRONG FUNDAMENTALS: Positive earnings growth, market leadership position. Institutional accumulation visible. RECOMMENDATION: BUY with 80% confidence. Target 15-20% upside.",
+                "📊 MIXED FUNDAMENTALS: Valuation concerns offset by solid cash flow. Competitive pressures increasing. RECOMMENDATION: HOLD and monitor for better entry.",
+                "📊 EXCELLENT GROWTH: Innovative product pipeline, expanding market share. Strong balance sheet. RECOMMENDATION: STRONG BUY for long-term growth."
+            ],
+            'technical': [
+                "📈 BULLISH PATTERN: Breakout above resistance. Support at ${support:.2f}. RSI: 65. ENTRY: Current levels. TARGET: ${target:.2f}.",
+                "📈 CONSOLIDATION PHASE: Trading range ${support:.2f}-${resistance:.2f}. Wait for breakout confirmation. Volume declining.",
+                "📈 STRONG UPTREND: Higher highs and higher lows. Volume confirmation. Fibonacci target: ${target:.2f}. Stop: ${stop:.2f}."
+            ],
+            'risk': [
+                "🛡️ MODERATE RISK: Position size 3-4%. Stop-loss 8%. Risk-reward 1:2.5. Maximum drawdown 12%.",
+                "🛡️ CONSERVATIVE: Position size 2-3%. Stop-loss 10% trailing. Monitor earnings date closely.",
+                "🛡️ FAVORABLE: Position size 4-5%. Stop-loss 6%. Risk-reward 1:3.0. Low portfolio correlation."
+            ]
+        }
         
-        # Combine all features (should be 4 + 3 + 3 + 6 = 16, take first 15)
-        all_features = price_features + portfolio_features + sentiment_features + technical_features
-        observation = np.array(all_features[:15], dtype=np.float32)
+        response = np.random.choice(responses[agent_type])
+        current_price = np.random.uniform(150, 250)
         
-        return observation
+        return response.format(
+            support=current_price * 0.95,
+            resistance=current_price * 1.08,
+            target=current_price * 1.15,
+            stop=current_price * 0.92
+        )
     
-    def _get_info(self) -> Dict[str, Any]:
-        """Get current environment information."""
-        net_worth = self.balance + self.position * self.current_price
-        return_total = ((net_worth - self.config.initial_balance) / 
-                       self.config.initial_balance * 100)
+    def generate_final_decision(self, symbol, current_price, analyses, metrics):
+        if metrics['price_change'] > 3 and metrics['volatility'] < 25:
+            decision = "BUY"
+            confidence = np.random.randint(75, 90)
+        elif metrics['price_change'] < -3:
+            decision = "SELL" 
+            confidence = np.random.randint(70, 85)
+        else:
+            decision = "HOLD"
+            confidence = np.random.randint(60, 80)
         
         return {
-            'net_worth': net_worth,
-            'return_percent': return_total,
-            'position_value': self.position * self.current_price,
-            'cash_balance': self.balance,
-            'current_price': self.current_price,
-            'steps': self.step_count,
-            'position': self.position,
-            'balance': self.balance
+            'name': 'Final Decision',
+            'emoji': '🎯',
+            'analysis': f"""🎯 FINAL DECISION: {decision}
+
+Confidence: {confidence}%
+Price: ${current_price:.2f}
+Position Size: {max(2, min(5, 8 - metrics['volatility']/10))}%
+
+Action: {'Enter long position' if decision == 'BUY' else 'Wait for better setup'}"""
         }
 
-# ---- 3. Deep Q-Network Agent ----
-class DQNAgent:
-    """Deep Q-Network agent for reinforcement learning trading."""
-    
-    ACTION_NAMES = {0: 'Hold', 1: 'Buy', 2: 'Sell', 3: 'Close'}
+# Initialize components
+market_data = MarketDataProvider()
+trading_agents = TradingAgents()
+
+# Gradio Interface Functions
+def create_stock_chart(symbol, price_data):
+    fig = go.Figure()
     
-    def __init__(self, state_dim: int, action_dim: int, config: TradingConfig, 
-                 device: str = None):
-        self.state_dim = state_dim
-        self.action_dim = action_dim
-        self.config = config
-        self.device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
-        
-        # Networks
-        self.q_network = self._build_network()
-        self.target_network = self._build_network()
-        self.target_network.load_state_dict(self.q_network.state_dict())
-        self.target_network.eval()
-        
-        # Training components
-        self.optimizer = optim.Adam(self.q_network.parameters(), lr=config.learning_rate)
-        self.criterion = nn.MSELoss()
-        self.memory = deque(maxlen=config.memory_size)
-        
-        # Epsilon-greedy parameters
-        self.epsilon = config.epsilon_start
-        self.epsilon_min = config.epsilon_min
-        self.epsilon_decay = config.epsilon_decay
-        
-        # Training state
-        self.batch_size = config.batch_size
-        self.gamma = config.gamma
-        self.target_update = config.target_update
-        self.steps = 0
+    fig.add_trace(go.Scatter(
+        x=price_data['dates'],
+        y=price_data['prices'],
+        mode='lines+markers',
+        name=f'{symbol} Price',
+        line=dict(color='#00D4AA', width=3),
+        marker=dict(size=6)
+    ))
     
-    def _build_network(self) -> nn.Module:
-        """Build deep neural network for Q-value approximation."""
-        return nn.Sequential(
-            nn.Linear(self.state_dim, self.config.hidden_size),
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(self.config.hidden_size, self.config.hidden_size),
-            nn.ReLU(),
-            nn.Dropout(0.2),
-            nn.Linear(self.config.hidden_size, self.config.hidden_size // 2),
-            nn.ReLU(),
-            nn.Linear(self.config.hidden_size // 2, self.action_dim)
-        ).to(self.device)
+    fig.update_layout(
+        title=f'{symbol} Price Chart - 30 Days',
+        xaxis_title='Date',
+        yaxis_title='Price ($)',
+        template='plotly_dark',
+        height=300,
+        margin=dict(l=50, r=50, t=50, b=50)
+    )
     
-    @torch.no_grad()
-    def select_action(self, state: np.ndarray, training: bool = True) -> int:
-        """Select action using epsilon-greedy policy."""
-        if training and random.random() < self.epsilon:
-            return random.randint(0, self.action_dim - 1)
-        
-        state_tensor = torch.FloatTensor(state).unsqueeze(0).to(self.device)
-        q_values = self.q_network(state_tensor)
-        return q_values.argmax(1).item()
+    return fig
+
+def create_performance_dashboard(stocks_data):
+    symbols = list(stocks_data.keys())
+    changes = [stocks_data[symbol]['change'] for symbol in symbols]
+    prices = [stocks_data[symbol]['current_price'] for symbol in symbols]
     
-    def store_transition(self, state: np.ndarray, action: int, 
-                        reward: float, next_state: np.ndarray, done: bool):
-        """Store experience tuple in replay memory."""
-        self.memory.append((state, action, reward, next_state, done))
+    fig = make_subplots(
+        rows=1, cols=2,
+        subplot_titles=['30-Day Performance (%)', 'Current Prices ($)'],
+        specs=[[{"type": "bar"}, {"type": "bar"}]]
+    )
     
-    def update(self) -> Optional[float]:
-        """Update Q-network using experience replay."""
-        if len(self.memory) < self.batch_size:
-            return None
-            
-        batch = random.sample(self.memory, self.batch_size)
-        states, actions, rewards, next_states, dones = zip(*batch)
-        
-        # Convert to tensors
-        states = torch.FloatTensor(np.array(states)).to(self.device)
-        actions = torch.LongTensor(actions).to(self.device)
-        rewards = torch.FloatTensor(rewards).to(self.device)
-        next_states = torch.FloatTensor(np.array(next_states)).to(self.device)
-        dones = torch.BoolTensor(dones).to(self.device)
-        
-        # Current Q-values
-        current_q_values = self.q_network(states).gather(1, actions.unsqueeze(1)).squeeze(1)
-        
-        # Target Q-values
-        with torch.no_grad():
-            next_q_values = self.target_network(next_states).max(1)[0]
-            target_q_values = rewards + self.gamma * next_q_values * (~dones).float()
-        
-        # Compute loss and update
-        loss = self.criterion(current_q_values, target_q_values)
-        self.optimizer.zero_grad()
-        loss.backward()
-        torch.nn.utils.clip_grad_norm_(self.q_network.parameters(), 1.0)
-        self.optimizer.step()
-        
-        self.steps += 1
-        
-        # Update target network
-        if self.steps % self.target_update == 0:
-            self.target_network.load_state_dict(self.q_network.state_dict())
-        
-        # Decay epsilon
-        self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)
-        
-        return loss.item()
+    colors = ['#00D4AA' if x >= 0 else '#FF6B6B' for x in changes]
+    fig.add_trace(go.Bar(x=symbols, y=changes, marker_color=colors), row=1, col=1)
+    fig.add_trace(go.Bar(x=symbols, y=prices, marker_color='#636EFA'), row=1, col=2)
     
-    def save_checkpoint(self, path: str):
-        """Save agent checkpoint."""
-        checkpoint = {
-            'q_network': self.q_network.state_dict(),
-            'target_network': self.target_network.state_dict(),
-            'optimizer': self.optimizer.state_dict(),
-            'epsilon': self.epsilon,
-            'steps': self.steps,
-            'config': self.config.__dict__
-        }
-        torch.save(checkpoint, path)
-        logger.info(f"Model saved to {path}")
+    fig.update_layout(
+        title='Stock Performance Overview',
+        template='plotly_dark',
+        height=400,
+        showlegend=False
+    )
     
-    def load_checkpoint(self, path: str):
-        """Load agent checkpoint."""
-        if os.path.exists(path):
-            try:
-                checkpoint = torch.load(path, map_location=self.device)
-                self.q_network.load_state_dict(checkpoint['q_network'])
-                self.target_network.load_state_dict(checkpoint['target_network'])
-                self.optimizer.load_state_dict(checkpoint['optimizer'])
-                self.epsilon = checkpoint['epsilon']
-                self.steps = checkpoint['steps']
-                logger.info(f"Model loaded from {path}")
-            except Exception as e:
-                logger.warning(f"Failed to load model from {path}: {e}")
+    return fig
 
-# ---- 4. Main Trading Application ----
-class TradingDemo:
-    """Main application integrating environment, agent, and UI."""
+def analyze_single_stock(symbol):
+    """Analyze a single stock"""
+    price_data = market_data.get_stock_data(symbol)
+    analyses = trading_agents.analyze_stock(symbol, price_data)
     
-    def __init__(self):
-        self.config = TradingConfig()
-        self.env: Optional[AdvancedTradingEnvironment] = None
-        self.agent: Optional[DQNAgent] = None
-        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        
-        # Training history
-        self.training_history = {
-            'rewards': [],
-            'losses': [],
-            'epsilons': [],
-            'net_worths': []
-        }
-        
-        # Model persistence
-        self.model_path = "dqn_trading_model.pth"
-        self.load_model_if_exists()
+    chart = create_stock_chart(symbol, price_data)
     
-    def load_model_if_exists(self):
-        """Load existing model if available."""
-        self.agent = None  # Reset agent first
-        if os.path.exists(self.model_path):
-            try:
-                # Create agent first, then load
-                temp_config = TradingConfig()
-                temp_env = AdvancedTradingEnvironment(temp_config)
-                self.agent = DQNAgent(
-                    state_dim=temp_env.observation_space_dim,
-                    action_dim=temp_env.action_space,
-                    config=temp_config,
-                    device=self.device
-                )
-                self.agent.load_checkpoint(self.model_path)
-                logger.info("✅ Loaded existing model checkpoint")
-            except Exception as e:
-                logger.warning(f"Failed to load model: {e}")
-                self.agent = None
+    analysis_output = f"# {symbol} Analysis Report\n\n"
+    analysis_output += f"**Current Price:** ${price_data['current_price']:.2f}\n"
+    analysis_output += f"**30-Day Change:** {price_data['change']:+.2f}%\n\n"
     
-    def initialize(self, balance: float, risk: str, asset: str) -> str:
-        """Initialize trading system with new parameters."""
-        try:
-            self.config.initial_balance = float(balance)
-            self.config.risk_level = risk
-            self.config.asset_type = asset
-            
-            self.env = AdvancedTradingEnvironment(self.config)
-            self.agent = DQNAgent(
-                state_dim=self.env.observation_space_dim,
-                action_dim=self.env.action_space,
-                config=self.config,
-                device=self.device
-            )
-            
-            # Reset training history
-            self.training_history = {
-                'rewards': [],
-                'losses': [],
-                'epsilons': [],
-                'net_worths': []
-            }
-            
-            return (f"✅ System initialized successfully!\n"
-                   f"💰 Balance: ${balance:,.2f}\n"
-                   f"🎯 Risk: {risk}\n"
-                   f"📈 Asset: {asset}\n"
-                   f"💻 Device: {self.device}")
-                   
-        except Exception as e:
-            logger.error(f"Initialization failed: {e}")
-            return f"❌ Initialization failed: {str(e)}"
+    for agent_type, analysis in analyses.items():
+        analysis_output += f"## {analysis['emoji']} {analysis['name']}\n"
+        analysis_output += f"{analysis['analysis']}\n\n"
     
-    def train(self, episodes: int) -> Generator[Tuple[str, Optional[go.Figure]], None, None]:
-        """Train the DQN agent."""
-        if not self.env or not self.agent:
-            yield "❌ Please initialize the system first!", None
-            return
-            
-        try:
-            episodes = int(episodes)
-            logger.info(f"Starting training for {episodes} episodes")
-            
-            for episode in range(episodes):
-                obs, _ = self.env.reset()
-                total_reward = 0
-                episode_losses = []
-                done = False
-                
-                while not done:
-                    action = self.agent.select_action(obs)
-                    next_obs, reward, terminated, truncated, info = self.env.step(action)
-                    done = terminated or truncated
-                    
-                    self.agent.store_transition(obs, action, reward, next_obs, done)
-                    loss = self.agent.update()
-                    if loss is not None:
-                        episode_losses.append(loss)
-                    
-                    total_reward += reward
-                    obs = next_obs
-                
-                # Record episode metrics
-                avg_loss = np.mean(episode_losses) if episode_losses else 0.0
-                self.training_history['rewards'].append(total_reward)
-                self.training_history['losses'].append(avg_loss)
-                self.training_history['epsilons'].append(self.agent.epsilon)
-                self.training_history['net_worths'].append(info['net_worth'])
-                
-                # Progress update
-                final_return = info['return_percent']
-                progress = (f"Episode {episode+1}/{episodes}\n"
-                           f"📈 Reward: {total_reward:.2f}\n"
-                           f"📉 Loss: {avg_loss:.4f}\n"
-                           f"🎯 Epsilon: {self.agent.epsilon:.3f}\n"
-                           f"💰 Net Worth: ${info['net_worth']:,.2f}\n"
-                           f"📊 Return: {final_return:.2f}%")
-                
-                # Generate plot every 10 episodes or at end
-                if (episode + 1) % 10 == 0 or episode == episodes - 1:
-                    plot = self._create_training_plot()
-                    yield progress, plot
-                else:
-                    yield progress, None
-            
-            # Save trained model
-            if self.agent:
-                self.agent.save_checkpoint(self.model_path)
-            yield "✅ Training completed! Model saved.", self._create_training_plot()
-            
-        except Exception as e:
-            logger.error(f"Training error: {e}")
-            yield f"❌ Training failed: {str(e)}", None
+    return chart, analysis_output
+
+def analyze_all_stocks():
+    """Analyze all tracked stocks"""
+    stocks_data = {}
+    for symbol in market_data.symbols:
+        stocks_data[symbol] = market_data.get_stock_data(symbol)
     
-    def simulate(self, steps: int) -> Tuple[str, Optional[go.Figure]]:
-        """Run trading simulation with trained agent."""
-        if not self.env or not self.agent:
-            return "❌ Please initialize and train the system first!", None
-            
-        try:
-            steps = int(steps)
-            obs, _ = self.env.reset()
-            
-            prices, actions, net_worths = [], [], []
-            portfolio_values, cash_balances = [], []
-            
-            for step in range(steps):
-                action = self.agent.select_action(obs, training=False)
-                next_obs, _, terminated, truncated, info = self.env.step(action)
-                
-                prices.append(self.env.current_price)
-                actions.append(action)
-                net_worths.append(info['net_worth'])
-                portfolio_values.append(info['position_value'])
-                cash_balances.append(info['cash_balance'])
-                
-                obs = next_obs
-                if terminated or truncated:
-                    break
-            
-            plot = self._create_simulation_plot(
-                prices, actions, net_worths, portfolio_values, cash_balances
-            )
-            
-            final_return = ((net_worths[-1] - self.config.initial_balance) / 
-                          self.config.initial_balance * 100)
-            
-            last_action_name = DQNAgent.ACTION_NAMES.get(actions[-1], 'Unknown')
-            result = (f"✅ Simulation completed!\n"
-                     f"📈 Steps: {len(prices)}\n"
-                     f"💰 Final Net Worth: ${net_worths[-1]:,.2f}\n"
-                     f"📊 Total Return: {final_return:.2f}%\n"
-                     f"🎯 Final Action: {last_action_name}")
-            
-            return result, plot
-            
-        except Exception as e:
-            logger.error(f"Simulation error: {e}")
-            return f"❌ Simulation failed: {str(e)}", None
+    dashboard = create_performance_dashboard(stocks_data)
     
-    def _create_training_plot(self) -> Optional[go.Figure]:
-        """Create comprehensive training progress visualization."""
-        if not self.training_history['rewards']:
-            return None
-            
-        episodes = list(range(1, len(self.training_history['rewards']) + 1))
-        
-        fig = make_subplots(
-            rows=2, cols=2,
-            subplot_titles=('Episode Rewards', 'Training Loss', 'Epsilon Decay', 'Portfolio Performance'),
-            vertical_spacing=0.12
-        )
-        
-        # Rewards
-        fig.add_trace(
-            go.Scatter(x=episodes, y=self.training_history['rewards'],
-                      mode='lines+markers', name='Total Reward',
-                      line=dict(color='blue', width=2)),
-            row=1, col=1
-        )
-        
-        # Moving average
-        window = min(20, len(episodes))
-        ma_rewards = [np.mean(self.training_history['rewards'][max(0, i-window):i+1])
-                     for i in range(len(episodes))]
-        fig.add_trace(
-            go.Scatter(x=episodes, y=ma_rewards, mode='lines',
-                      name='MA Reward', line=dict(color='orange', width=3)),
-            row=1, col=1
-        )
-        
-        # Losses
-        fig.add_trace(
-            go.Scatter(x=episodes, y=self.training_history['losses'],
-                      mode='lines', name='Loss', line=dict(color='red')),
-            row=1, col=2
-        )
-        
-        # Epsilon
-        fig.add_trace(
-            go.Scatter(x=episodes, y=self.training_history['epsilons'],
-                      mode='lines', name='Epsilon', line=dict(color='green')),
-            row=2, col=1
-        )
-        
-        # Portfolio performance
-        returns = [(nw - self.config.initial_balance) / self.config.initial_balance * 100
-                  for nw in self.training_history['net_worths']]
-        fig.add_trace(
-            go.Scatter(x=episodes, y=self.training_history['net_worths'],
-                      mode='lines', name='Net Worth',
-                      line=dict(color='blue'), yaxis='y'),
-            row=2, col=2
-        )
-        fig.add_trace(
-            go.Scatter(x=episodes, y=returns, mode='lines',
-                      name='Return %', line=dict(color='purple'), yaxis='y2'),
-            row=2, col=2
-        )
-        
-        fig.update_layout(
-            height=700,
-            showlegend=True,
-            title_text="🧠 DQN Training Progress",
-            hovermode='x unified'
-        )
-        
-        fig.update_yaxes(title_text="Return (%)", secondary_y=True, row=2, col=2)
-        fig.update_yaxes(title_text="Net Worth ($)", row=2, col=2)
-        
-        return fig
+    analysis_output = "# Multi-Agent Trading Analysis\n\n"
     
-    def _create_simulation_plot(self, prices: List[float], actions: List[int],
-                              net_worths: List[float], portfolio_values: List[float],
-                              cash_balances: List[float]) -> go.Figure:
-        """Create detailed simulation results visualization."""
-        steps = list(range(len(prices)))
-        
-        fig = make_subplots(
-            rows=2, cols=2,
-            subplot_titles=('Price Action & Trading Signals', 'Portfolio Performance',
-                          'Portfolio Allocation', 'Action Distribution'),
-            vertical_spacing=0.12
-        )
-        
-        # Price and actions
-        fig.add_trace(
-            go.Scatter(x=steps, y=prices, mode='lines', name='Asset Price',
-                      line=dict(color='blue', width=2)),
-            row=1, col=1
-        )
-        
-        # Action markers
-        action_colors = ['gray', 'green', 'red', 'orange']
-        action_names = list(DQNAgent.ACTION_NAMES.values())
-        
-        for action, color, name in zip(range(4), action_colors, action_names):
-            action_steps = [i for i, a in enumerate(actions) if a == action]
-            if action_steps:
-                action_prices = [prices[i] for i in action_steps]
-                fig.add_trace(
-                    go.Scatter(x=action_steps, y=action_prices, mode='markers',
-                              name=f'{name}',
-                              marker=dict(color=color, size=8, symbol='triangle-up')),
-                    row=1, col=1
-                )
-        
-        # Portfolio performance
-        initial_balance = self.config.initial_balance
-        returns = [(nw - initial_balance) / initial_balance * 100 for nw in net_worths]
-        
-        fig.add_trace(
-            go.Scatter(x=steps, y=net_worths, mode='lines', name='Net Worth',
-                      line=dict(color='purple', width=2)),
-            row=1, col=2
-        )
-        fig.add_trace(
-            go.Scatter(x=steps, y=returns, mode='lines', name='Returns %',
-                      line=dict(color='orange', width=2), yaxis='y2'),
-            row=1, col=2
-        )
-        
-        # Portfolio composition
-        fig.add_trace(
-            go.Scatter(x=steps, y=portfolio_values, mode='lines',
-                      name='Portfolio Value', line=dict(color='green')),
-            row=2, col=1
-        )
-        fig.add_trace(
-            go.Scatter(x=steps, y=cash_balances, mode='lines',
-                      name='Cash Balance', line=dict(color='blue')),
-            row=2, col=1
-        )
-        
-        # Action distribution
-        action_counts = [actions.count(i) for i in range(4)]
-        fig.add_trace(
-            go.Bar(x=action_names, y=action_counts, name='Action Frequency',
-                  marker_color=action_colors),
-            row=2, col=2
-        )
-        
-        fig.update_layout(
-            height=700,
-            showlegend=True,
-            title_text="📈 Trading Simulation Results",
-            hovermode='x unified'
-        )
-        
-        fig.update_yaxes(title_text="Returns (%)", secondary_y=True, row=1, col=2)
-        fig.update_yaxes(title_text="Value ($)", row=1, col=2)
-        
-        return fig
-
-# ---- 5. Gradio Interface for Hugging Face ----
-def create_interface() -> gr.Blocks:
-    """Create professional Gradio interface."""
-    demo = TradingDemo()
+    for symbol in market_data.symbols:
+        analyses = trading_agents.analyze_stock(symbol, stocks_data[symbol])
+        decision_line = analyses['decision']['analysis'].split('\n')[0]
+        
+        analysis_output += f"## {symbol}\n"
+        analysis_output += f"**Price:** ${stocks_data[symbol]['current_price']:.2f} | "
+        analysis_output += f"**Change:** {stocks_data[symbol]['change']:+.2f}%\n"
+        analysis_output += f"**Decision:** {decision_line}\n\n"
     
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        title="🤖 Advanced AI Trading Demo",
-        css="""
-        .gradio-container {max-width: 1400px !important;}
-        .status-box {background-color: #f0f9ff; padding: 1rem; border-radius: 8px; border-left: 4px solid #3b82f6;}
-        """
-    ) as interface:
-        
-        gr.Markdown("""
-        # 🤖 Advanced AI Trading Demo
-        **Deep Reinforcement Learning for Financial Markets**
+    return dashboard, analysis_output
 
-        This demo showcases a **Deep Q-Network (DQN)** agent learning to trade in simulated financial markets with realistic market dynamics, technical indicators, and risk management.
-        """)
-        
-        # Configuration Row
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("## 🎯 System Configuration")
-                with gr.Group():
-                    balance = gr.Slider(
-                        1000, 50000, 10000, step=1000,
-                        label="💰 Initial Balance ($)"
-                    )
-                    risk = gr.Radio(
-                        ["Low", "Medium", "High"], value="Medium",
-                        label="🎯 Risk Level"
-                    )
-                    asset = gr.Radio(
-                        ["Crypto", "Stock", "Forex"], value="Crypto",
-                        label="📈 Asset Type"
-                    )
-                    init_btn = gr.Button("🚀 Initialize Trading System", variant="primary")
-            
-            with gr.Column(scale=2):
-                gr.Markdown("## 📊 System Status")
-                status = gr.Markdown(
-                    value="👋 Welcome! Configure parameters and click **Initialize** to begin.",
-                    elem_classes=["status-box"]
-                )
-        
-        # Training and Simulation Row
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("## 🏋️‍♂️ Train AI Agent")
-                with gr.Group():
-                    episodes = gr.Number(
-                        value=50, label="🎯 Training Episodes", precision=0
-                    )
-                    train_btn = gr.Button("🎓 Start Training", variant="primary")
-                    training_output = gr.Textbox(
-                        label="Training Progress", lines=6, interactive=False
-                    )
-                    train_plot = gr.Plot(label="📈 Training Progress")
-            
-            with gr.Column():
-                gr.Markdown("## ▶️ Test Trained Agent")
-                with gr.Group():
-                    sim_steps = gr.Number(
-                        value=200, label="📊 Simulation Steps", precision=0
-                    )
-                    sim_btn = gr.Button("🎮 Run Simulation", variant="primary")
-                    sim_output = gr.Textbox(
-                        label="Simulation Results", lines=4, interactive=False
-                    )
-                    sim_plot = gr.Plot(label="📊 Trading Results")
-        
-        # Event Handlers
-        def initialize_wrapper(balance, risk, asset):
-            return demo.initialize(balance, risk, asset)
-        
-        def simulate_wrapper(steps):
-            return demo.simulate(steps)
-        
-        def train_generator(episodes):
-            try:
-                for status_text, plot in demo.train(int(episodes)):
-                    yield status_text, plot
-            except Exception as e:
-                yield f"❌ Training error: {str(e)}", None
-        
-        init_btn.click(
-            fn=initialize_wrapper,
-            inputs=[balance, risk, asset],
-            outputs=status
-        )
-        
-        train_btn.queue().click(
-            fn=train_generator,
-            inputs=episodes,
-            outputs=[training_output, train_plot]
-        )
-        
-        sim_btn.click(
-            fn=simulate_wrapper,
-            inputs=sim_steps,
-            outputs=[sim_output, sim_plot]
-        )
-        
-        gr.Markdown("""
-        ## 📖 Usage Instructions
-        1. **Configure** your trading parameters
-        2. **Initialize** the trading system
-        3. **Train** the AI agent (50+ episodes recommended)
-        4. **Simulate** trading with the trained agent
+def update_analysis(symbol_input):
+    """Update analysis based on user input"""
+    if symbol_input:
+        symbol = symbol_input.upper().strip()
+        return analyze_single_stock(symbol)
+    else:
+        return analyze_all_stocks()
+
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Trading Agents") as demo:
+    gr.Markdown("""
+    # 🤖 Multi-Agent AI Trading System
+    **Professional stock analysis powered by AI agents**
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            symbol_input = gr.Textbox(
+                label="Enter Stock Symbol (e.g., AAPL, TSLA)",
+                placeholder="Leave empty for all tracked stocks...",
+                max_lines=1
+            )
+            analyze_btn = gr.Button("Analyze Stock", variant="primary")
         
-        ## 🎮 Trading Actions
-        - **Hold (0)**: Maintain current position
-        - **Buy (1)**: Purchase assets (risk-adjusted)
-        - **Sell (2)**: Sell portion of position
-        - **Close (3)**: Liquidate entire position
-        """)
+        with gr.Column(scale=2):
+            gr.Markdown("### Live Market Analysis")
+    
+    with gr.Tabs():
+        with gr.TabItem("📈 Charts"):
+            with gr.Row():
+                chart_output = gr.Plot(label="Price Chart")
+                dashboard_output = gr.Plot(label="Performance Dashboard")
+        
+        with gr.TabItem("📊 Analysis"):
+            analysis_output = gr.Markdown(label="AI Analysis Report")
     
-    return interface
+    # Event handlers
+    analyze_btn.click(
+        fn=update_analysis,
+        inputs=[symbol_input],
+        outputs=[chart_output, analysis_output]
+    )
+    
+    # Load initial analysis
+    demo.load(
+        fn=analyze_all_stocks,
+        outputs=[dashboard_output, analysis_output]
+    )
 
-# ---- 6. Hugging Face Spaces Entry Point ----
+# For Hugging Face Spaces
 if __name__ == "__main__":
-    try:
-        interface = create_interface()
-        interface.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,
-            show_error=True,
-            enable_queue=True,
-            max_threads=40,
-            debug=False
-        )
-    except Exception as e:
-        logger.error(f"Failed to launch application: {e}")
-        raise
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )