Update app.py

app.py

@@ -11,6 +11,7 @@ from plotly.subplots import make_subplots
 import time
 import sys
 import os
+from datetime import datetime
 
 # Set matplotlib backend
 plt.switch_backend('Agg')
@@ -30,42 +31,64 @@ for dir_path in ['src', 'src/environments', 'src/agents', 'src/sentiment', 'src/
 sys.path.append('src')
 
 # Import our custom modules
-from src.environments.visual_trading_env import VisualTradingEnvironment
-from src.agents.visual_agent import VisualTradingAgent
+from src.environments.advanced_trading_env import AdvancedTradingEnvironment
+from src.agents.advanced_agent import AdvancedTradingAgent
 from src.visualizers.chart_renderer import ChartRenderer
+from src.sentiment.twitter_analyzer import AdvancedSentimentAnalyzer
 
-class TradingAIDemo:
+class ProfessionalTradingAIDemo:
     def __init__(self):
         self.env = None
         self.agent = None
+        self.sentiment_analyzer = AdvancedSentimentAnalyzer()
         self.current_state = None
         self.is_training = False
         self.episode_history = []
+        self.sentiment_history = []
         self.chart_renderer = ChartRenderer()
         self.initialized = False
+        self.use_sentiment = True
         
-    def initialize_environment(self, initial_balance, risk_level, asset_type):
-        """Initialize trading environment"""
+    def initialize_environment(self, initial_balance, risk_level, asset_type, use_sentiment, sentiment_influence):
+        """Initialize professional trading environment with sentiment analysis"""
         try:
-            print(f"Initializing environment with balance: {initial_balance}, risk: {risk_level}, asset: {asset_type}")
+            print(f"Initializing professional trading environment...")
             
-            self.env = VisualTradingEnvironment(
+            self.use_sentiment = use_sentiment
+            self.env = AdvancedTradingEnvironment(
                 initial_balance=float(initial_balance),
                 risk_level=risk_level,
-                asset_type=asset_type
+                asset_type=asset_type,
+                use_sentiment=use_sentiment,
+                sentiment_influence=float(sentiment_influence)
             )
             
-            # Initialize agent with correct dimensions
-            self.agent = VisualTradingAgent(
+            # Initialize sentiment analyzer if needed
+            if use_sentiment:
+                sentiment_loaded = self.sentiment_analyzer.initialize_models()
+                if not sentiment_loaded:
+                    return "❌ Failed to load sentiment analysis models. Please check internet connection."
+            
+            # Initialize advanced agent
+            self.agent = AdvancedTradingAgent(
                 state_dim=(84, 84, 4),
-                action_dim=4
+                action_dim=4,
+                use_sentiment=use_sentiment
             )
             
             self.current_state = self.env.reset()
             self.episode_history = []
+            self.sentiment_history = []
             self.initialized = True
             
-            return "✅ Environment initialized successfully! Ready for trading."
+            status_msg = "✅ Professional Trading Environment Initialized!"
+            if use_sentiment:
+                status_msg += f"\n🎯 Sentiment Analysis: ACTIVE (Influence: {sentiment_influence})"
+                status_msg += f"\n📊 Influencers: {len(self.sentiment_analyzer.influencers)} accounts monitored"
+            else:
+                status_msg += "\n🎯 Sentiment Analysis: DISABLED"
+            
+            return status_msg
             
         except Exception as e:
             error_msg = f"❌ Error initializing environment: {str(e)}"
@@ -73,21 +96,46 @@ class TradingAIDemo:
             return error_msg
     
     def run_single_step(self, action_choice):
-        """Run a single step in the environment"""
+        """Run a single step with sentiment analysis"""
         if not self.initialized or self.env is None or self.agent is None:
-            return None, None, None, "⚠️ Please initialize environment first!"
+            return None, None, None, None, "⚠️ Please initialize environment first!"
         
         try:
-            # Use selected action or let agent decide
+            # Get current sentiment if enabled
+            current_sentiment = 0.5
+            sentiment_confidence = 0.0
+            sentiment_data = None
+            sentiment_analysis = None
+            
+            if self.use_sentiment:
+                sentiment_analysis = self.env.get_sentiment_analysis()
+                current_sentiment = sentiment_analysis.get('current_sentiment', 0.5)
+                sentiment_confidence = sentiment_analysis.get('sentiment_confidence', 0.0)
+                
+                # Update sentiment history
+                self.sentiment_history.append({
+                    'step': len(self.episode_history),
+                    'sentiment': current_sentiment,
+                    'confidence': sentiment_confidence,
+                    'timestamp': datetime.now()
+                })
+                if len(self.sentiment_history) > 50:
+                    self.sentiment_history.pop(0)
+            
+            # Select action with sentiment consideration
             if action_choice == "AI Decision":
-                action = self.agent.select_action(self.current_state)
+                action = self.agent.select_action(
+                    self.current_state, 
+                    current_sentiment, 
+                    sentiment_confidence
+                )
                 action_source = "AI"
             else:
                 action_mapping = {"Hold": 0, "Buy": 1, "Sell": 2, "Close": 3}
                 action = action_mapping[action_choice]
                 action_source = "Manual"
             
-            print(f"Executing action: {action} ({action_source})")
+            print(f"Executing action: {action} ({action_source}) | Sentiment: {current_sentiment:.3f}")
             
             # Execute action
             next_state, reward, done, info = self.env.step(action)
@@ -102,7 +150,9 @@ class TradingAIDemo:
                 'balance': info['balance'],
                 'position': info['position_size'],
                 'price': info['current_price'],
-                'action_source': action_source
+                'action_source': action_source,
+                'sentiment': current_sentiment,
+                'sentiment_confidence': sentiment_confidence
             }
             self.episode_history.append(history_entry)
             
@@ -110,33 +160,35 @@ class TradingAIDemo:
             price_chart = self.create_price_chart(info)
             performance_chart = self.create_performance_chart()
             action_chart = self.create_action_chart()
+            sentiment_chart = self.create_sentiment_chart()
             
             # Create status message
             action_names = ["Hold", "Buy", "Sell", "Close"]
+            sentiment_label = "🔴 Bearish" if current_sentiment < 0.4 else "🟡 Neutral" if current_sentiment < 0.6 else "🟢 Bullish"
+            
             status = (
                 f"✅ Step {info['step']} Completed!\n"
                 f"• Action: {action_names[action]} ({action_source})\n"
                 f"• Reward: {reward:.3f}\n"
                 f"• Net Worth: ${info['net_worth']:.2f}\n"
-                f"• Balance: ${info['balance']:.2f}\n"
-                f"• Position: {info['position_size']:.4f}\n"
-                f"• Current Price: ${info['current_price']:.2f}"
+                f"• Market Sentiment: {sentiment_label} ({current_sentiment:.3f})\n"
+                f"• Sentiment Confidence: {sentiment_confidence:.1%}"
             )
             
             if done:
                 status += "\n🎯 Episode Completed!"
             
-            return price_chart, performance_chart, action_chart, status
+            return price_chart, performance_chart, action_chart, sentiment_chart, status
             
         except Exception as e:
             error_msg = f"❌ Error during step execution: {str(e)}"
             print(error_msg)
-            return None, None, None, error_msg
+            return None, None, None, None, error_msg
     
     def run_episode(self, num_steps=20):
-        """Run a complete episode"""
+        """Run a complete episode with sentiment analysis"""
         if not self.initialized or self.env is None or self.agent is None:
-            return None, None, None, "⚠️ Please initialize environment first!"
+            return None, None, None, None, "⚠️ Please initialize environment first!"
         
         try:
             # Reset environment for new episode
@@ -147,13 +199,27 @@ class TradingAIDemo:
             print(f"Starting episode with {num_steps} steps...")
             
             for step in range(num_steps):
-                action = self.agent.select_action(self.current_state)
+                # Get current sentiment
+                current_sentiment = 0.5
+                sentiment_confidence = 0.0
+                
+                if self.use_sentiment:
+                    sentiment_info = self.env.get_sentiment_analysis()
+                    current_sentiment = sentiment_info.get('current_sentiment', 0.5)
+                    sentiment_confidence = sentiment_info.get('sentiment_confidence', 0.0)
+                
+                # Select action with sentiment
+                action = self.agent.select_action(self.current_state, current_sentiment, sentiment_confidence)
                 next_state, reward, done, info = self.env.step(action)
                 self.current_state = next_state
                 total_reward += reward
                 
-                # Store experience for training
-                self.agent.store_transition(self.current_state, action, reward, next_state, done)
+                # Store experience with sentiment data
+                sentiment_data = {
+                    'sentiment': current_sentiment,
+                    'confidence': sentiment_confidence
+                }
+                self.agent.store_transition(self.current_state, action, reward, next_state, done, sentiment_data)
                 
                 self.episode_history.append({
                     'step': step,
@@ -161,6 +227,7 @@ class TradingAIDemo:
                     'reward': reward,
                     'net_worth': info['net_worth'],
                     'price': info['current_price'],
+                    'sentiment': current_sentiment,
                     'action_source': 'AI'
                 })
                 
@@ -174,6 +241,7 @@ class TradingAIDemo:
             price_chart = self.create_price_chart(info)
             performance_chart = self.create_performance_chart()
             action_chart = self.create_action_chart()
+            sentiment_chart = self.create_sentiment_chart()
             
             # Calculate performance metrics
             initial_balance = self.env.initial_balance
@@ -182,26 +250,58 @@ class TradingAIDemo:
             if initial_balance > 0:
                 total_return = (final_net_worth - initial_balance) / initial_balance * 100
             
+            # Calculate average sentiment
+            avg_sentiment = np.mean([h['sentiment'] for h in self.episode_history]) if self.episode_history else 0.5
+            
             summary = (
                 f"🎯 Episode Completed!\n"
                 f"• Total Steps: {len(self.episode_history)}\n"
                 f"• Total Reward: {total_reward:.2f}\n"
                 f"• Final Net Worth: ${final_net_worth:.2f}\n"
                 f"• Total Return: {total_return:.2f}%\n"
+                f"• Average Sentiment: {avg_sentiment:.3f}\n"
                 f"• Total Trades: {info['total_trades']}"
             )
             
-            return price_chart, performance_chart, action_chart, summary
+            return price_chart, performance_chart, action_chart, sentiment_chart, summary
             
         except Exception as e:
             error_msg = f"❌ Error during episode: {str(e)}"
             print(error_msg)
-            return None, None, None, error_msg
+            return None, None, None, None, error_msg
+    
+    def get_sentiment_analysis_report(self):
+        """Get detailed sentiment analysis report"""
+        if not self.use_sentiment or not self.initialized:
+            return "❌ Sentiment analysis is not enabled"
+        
+        try:
+            sentiment_data = self.sentiment_analyzer.get_influencer_sentiment()
+            
+            report = (
+                f"📊 Real-time Market Sentiment Analysis\n"
+                f"• Overall Sentiment: {sentiment_data['market_sentiment']:.3f}\n"
+                f"• Confidence: {sentiment_data['confidence']:.1%}\n"
+                f"• Influencers Analyzed: {sentiment_data['influencer_count']}\n"
+                f"• Total Tweets: {sentiment_data['total_tweets']}\n"
+                f"• Last Update: {sentiment_data['timestamp']}"
+            )
+            
+            # Add top influencers
+            top_influencers = list(sentiment_data['breakdown'].items())[:3]
+            for username, data in top_influencers:
+                sentiment_emoji = "🔴" if data['score'] < 0.4 else "🟡" if data['score'] < 0.6 else "🟢"
+                report += f"\n• {sentiment_emoji} {username}: {data['score']:.3f} (conf: {data['confidence']:.1%})"
+            
+            return report
+            
+        except Exception as e:
+            return f"❌ Error getting sentiment report: {str(e)}"
     
     def train_agent(self, num_episodes, learning_rate):
-        """Train the AI agent"""
+        """Train the AI agent with sentiment-enhanced learning"""
         if not self.initialized or self.env is None:
-            yield None, "⚠️ Please initialize environment first!"
+            yield None, None, "⚠️ Please initialize environment first!"
             return
         
         self.is_training = True
@@ -216,9 +316,26 @@ class TradingAIDemo:
                 steps = 0
                 
                 while not done and steps < 100:
-                    action = self.agent.select_action(state)
+                    # Get sentiment for this step
+                    current_sentiment = 0.5
+                    sentiment_confidence = 0.0
+                    
+                    if self.use_sentiment:
+                        sentiment_info = self.env.get_sentiment_analysis()
+                        current_sentiment = sentiment_info.get('current_sentiment', 0.5)
+                        sentiment_confidence = sentiment_info.get('sentiment_confidence', 0.0)
+                    
+                    # Select action with sentiment
+                    action = self.agent.select_action(state, current_sentiment, sentiment_confidence)
                     next_state, reward, done, info = self.env.step(action)
-                    self.agent.store_transition(state, action, reward, next_state, done)
+                    
+                    # Store experience with sentiment data
+                    sentiment_data = {
+                        'sentiment': current_sentiment,
+                        'confidence': sentiment_confidence
+                    }
+                    self.agent.store_transition(state, action, reward, next_state, done, sentiment_data)
+                    
                     state = next_state
                     episode_reward += reward
                     steps += 1
@@ -270,9 +387,8 @@ class TradingAIDemo:
             yield None, error_msg
     
     def create_price_chart(self, info):
-        """Create price chart with actions"""
+        """Create price chart with actions and sentiment markers"""
         if not self.episode_history:
-            # Return empty chart with message
             fig = go.Figure()
             fig.update_layout(
                 title="Price Chart - No Data Available",
@@ -285,6 +401,7 @@ class TradingAIDemo:
         
         prices = [h['price'] for h in self.episode_history]
         actions = [h['action'] for h in self.episode_history]
+        sentiments = [h.get('sentiment', 0.5) for h in self.episode_history]
         
         fig = go.Figure()
         
@@ -297,43 +414,40 @@ class TradingAIDemo:
             line=dict(color='blue', width=3)
         ))
         
-        # Action markers
-        buy_indices = [i for i, action in enumerate(actions) if action == 1]
-        sell_indices = [i for i, action in enumerate(actions) if action == 2]
-        close_indices = [i for i, action in enumerate(actions) if action == 3]
-        
-        if buy_indices:
-            fig.add_trace(go.Scatter(
-                x=buy_indices,
-                y=[prices[i] for i in buy_indices],
-                mode='markers',
-                name='Buy',
-                marker=dict(color='green', size=12, symbol='triangle-up', 
-                          line=dict(width=2, color='darkgreen'))
-            ))
-        
-        if sell_indices:
-            fig.add_trace(go.Scatter(
-                x=sell_indices,
-                y=[prices[i] for i in sell_indices],
-                mode='markers',
-                name='Sell',
-                marker=dict(color='red', size=12, symbol='triangle-down', 
-                          line=dict(width=2, color='darkred'))
-            ))
-        
-        if close_indices:
-            fig.add_trace(go.Scatter(
-                x=close_indices,
-                y=[prices[i] for i in close_indices],
-                mode='markers',
-                name='Close',
-                marker=dict(color='orange', size=10, symbol='x', 
-                          line=dict(width=2, color='darkorange'))
-            ))
+        # Action markers with sentiment coloring
+        for i, (action, sentiment) in enumerate(zip(actions, sentiments)):
+            if action == 1:  # Buy
+                color = 'green' if sentiment > 0.6 else 'lightgreen' if sentiment > 0.4 else 'darkgreen'
+                fig.add_trace(go.Scatter(
+                    x=[i], y=[prices[i]],
+                    mode='markers',
+                    name='Buy' if i == 1 else '',
+                    marker=dict(color=color, size=12, symbol='triangle-up', 
+                              line=dict(width=2, color='darkgreen')),
+                    showlegend=False
+                ))
+            elif action == 2:  # Sell
+                color = 'red' if sentiment < 0.4 else 'lightcoral' if sentiment < 0.6 else 'darkred'
+                fig.add_trace(go.Scatter(
+                    x=[i], y=[prices[i]],
+                    mode='markers',
+                    name='Sell' if i == 2 else '',
+                    marker=dict(color=color, size=12, symbol='triangle-down', 
+                              line=dict(width=2, color='darkred')),
+                    showlegend=False
+                ))
+            elif action == 3:  # Close
+                fig.add_trace(go.Scatter(
+                    x=[i], y=[prices[i]],
+                    mode='markers',
+                    name='Close' if i == 3 else '',
+                    marker=dict(color='orange', size=10, symbol='x', 
+                              line=dict(width=2, color='darkorange')),
+                    showlegend=False
+                ))
         
         fig.update_layout(
-            title="Price Chart with Trading Actions",
+            title="Price Chart with Trading Actions (Colored by Sentiment)",
             xaxis_title="Step",
             yaxis_title="Price",
             height=350,
@@ -429,6 +543,68 @@ class TradingAIDemo:
         
         return fig
     
+    def create_sentiment_chart(self):
+        """Create sentiment analysis chart"""
+        if not self.sentiment_history:
+            fig = go.Figure()
+            fig.update_layout(
+                title="Sentiment Analysis - No Data Available",
+                height=300
+            )
+            return fig
+        
+        steps = [h['step'] for h in self.sentiment_history]
+        sentiments = [h['sentiment'] for h in self.sentiment_history]
+        confidences = [h['confidence'] for h in self.sentiment_history]
+        
+        fig = go.Figure()
+        
+        # Sentiment line
+        fig.add_trace(go.Scatter(
+            x=steps,
+            y=sentiments,
+            mode='lines+markers',
+            name='Market Sentiment',
+            line=dict(color='purple', width=3),
+            marker=dict(size=6)
+        ))
+        
+        # Confidence as shaded area
+        fig.add_trace(go.Scatter(
+            x=steps,
+            y=[s + c/2 for s, c in zip(sentiments, confidences)],
+            mode='lines',
+            name='Confidence Upper',
+            line=dict(width=0),
+            showlegend=False
+        ))
+        
+        fig.add_trace(go.Scatter(
+            x=steps,
+            y=[s - c/2 for s, c in zip(sentiments, confidences)],
+            mode='lines',
+            name='Confidence Lower',
+            fill='tonexty',
+            fillcolor='rgba(128, 0, 128, 0.2)',
+            line=dict(width=0),
+            showlegend=False
+        ))
+        
+        # Add sentiment level lines
+        fig.add_hline(y=0.6, line_dash="dash", line_color="green", annotation_text="Bullish Threshold")
+        fig.add_hline(y=0.4, line_dash="dash", line_color="red", annotation_text="Bearish Threshold")
+        
+        fig.update_layout(
+            title="Market Sentiment Analysis Over Time",
+            xaxis_title="Step",
+            yaxis_title="Sentiment Score",
+            height=350,
+            yaxis=dict(range=[0, 1]),
+            template="plotly_white"
+        )
+        
+        return fig
+    
     def create_training_progress(self, training_history):
         """Create training progress visualization"""
         if not training_history:
@@ -496,48 +672,60 @@ class TradingAIDemo:
         return fig
 
 # Initialize the demo
-demo = TradingAIDemo()
+demo = ProfessionalTradingAIDemo()
 
 # Create Gradio interface
 def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft(), title="Visual Trading AI") as interface:
+    with gr.Blocks(theme=gr.themes.Soft(), title="Professional Trading AI") as interface:
         gr.Markdown("""
-        # 🚀 Visual Trading AI
-        **هوش مصنوعی معامله‌گر بصری - تحلیل چارت‌های قیمت با یادگیری تقویتی عمیق**
+        # 🚀 Professional Trading AI
+        **ترکیب هوش مصنوعی پیشرفته: تحلیل توئییت + CNN + یادگیری تقویتی**
         
-        *این پروژه از ترکیب **CNN برای پردازش بصری** نمودارها و **یادگیری تقویتی** برای تصمیم‌گیری استفاده می‌کند.*
+        *این سیستم از **تحلیل احساسات توئییت‌های افراد تاثیرگذار**، **پردازش بصری نمودارها با CNN** و **یادگیری تقویتی** برای تصمیم‌گیری هوشمند استفاده می‌کند.*
         """)
         
         with gr.Row():
             with gr.Column(scale=1):
                 # Configuration section
-                gr.Markdown("## ⚙️ پیکربندی محیط")
+                gr.Markdown("## ⚙️ پیکربندی حرفه‌ای")
                 
                 with gr.Row():
                     initial_balance = gr.Slider(
                         minimum=1000, maximum=50000, value=10000, step=1000,
-                        label="موجودی اولیه ($)", info="میزان سرمایه اولیه برای معامله"
+                        label="موجودی اولیه ($)", info="میزان سرمایه اولیه"
                     )
                 
                 with gr.Row():
                     risk_level = gr.Radio(
                         ["Low", "Medium", "High"], 
                         value="Medium",
-                        label="سطح ریسک",
-                        info="سطح ریسک پذیری در معاملات"
+                        label="سطح ریسک"
                     )
                 
                 with gr.Row():
                     asset_type = gr.Radio(
                         ["Stock", "Crypto", "Forex"], 
-                        value="Stock",
-                        label="نوع دارایی",
-                        info="نوع بازار مالی برای شبیه‌سازی"
+                        value="Crypto",
+                        label="نوع دارایی"
+                    )
+                
+                with gr.Row():
+                    use_sentiment = gr.Checkbox(
+                        value=True,
+                        label="فعال‌سازی تحلیل احساسات توئییت",
+                        info="آنالیز توئییت‌های افراد تاثیرگذار"
+                    )
+                
+                with gr.Row():
+                    sentiment_influence = gr.Slider(
+                        minimum=0.1, maximum=0.8, value=0.3, step=0.1,
+                        label="تاثیر تحلیل احساسات",
+                        info="میزان تاثیرگذاری تحلیل توئییت‌ها بر تصمیم‌ها"
                     )
                 
                 with gr.Row():
                     init_btn = gr.Button(
-                        "🚀 راه‌اندازی محیط معاملاتی", 
+                        "🚀 راه‌اندازی سیستم حرفه‌ای", 
                         variant="primary",
                         size="lg"
                     )
@@ -546,8 +734,7 @@ def create_interface():
                     init_status = gr.Textbox(
                         label="وضعیت راه‌اندازی",
                         interactive=False,
-                        placeholder="برای شروع، محیط را راه‌اندازی کنید...",
-                        lines=2
+                        lines=3
                     )
             
             with gr.Column(scale=2):
@@ -556,8 +743,7 @@ def create_interface():
                 status_output = gr.Textbox(
                     label="وضعیت اجرا",
                     interactive=False,
-                    placeholder="وضعیت معاملات اینجا نمایش داده می‌شود...",
-                    lines=4
+                    lines=5
                 )
         
         with gr.Row():
@@ -569,7 +755,7 @@ def create_interface():
                 ["AI Decision", "Buy", "Sell", "Hold", "Close"],
                 value="AI Decision",
                 label="انتخاب اقدام",
-                info="AI Decision: تصمیم خودکار هوش مصنوعی"
+                info="AI Decision: ترکیب CNN + RL + تحلیل احساسات"
             )
             
         with gr.Row():
@@ -586,6 +772,13 @@ def create_interface():
                     variant="secondary",
                     size="lg"
                 )
+            
+            with gr.Column(scale=1):
+                sentiment_btn = gr.Button(
+                    "📊 گزارش تحلیل احساسات", 
+                    variant="secondary",
+                    size="lg"
+                )
         
         with gr.Row():
             # Visualization outputs
@@ -604,6 +797,11 @@ def create_interface():
                 action_chart = gr.Plot(
                     label="🎯 توزیع اقدامات"
                 )
+            
+            with gr.Column(scale=1):
+                sentiment_chart = gr.Plot(
+                    label="😊 تحلیل احساسات بازار"
+                )
         
         with gr.Row():
             gr.Markdown("## 🎓 آموزش هوش مصنوعی")
@@ -612,18 +810,16 @@ def create_interface():
             with gr.Column(scale=1):
                 num_episodes = gr.Slider(
                     minimum=10, maximum=200, value=50, step=10,
-                    label="تعداد اپیزودهای آموزش",
-                    info="تعداد دوره‌های آموزشی"
+                    label="تعداد اپیزودهای آموزش"
                 )
                 
                 learning_rate = gr.Slider(
                     minimum=0.0001, maximum=0.01, value=0.001, step=0.0001,
-                    label="نرخ یادگیری",
-                    info="سرعت یادگیری الگوریتم"
+                    label="نرخ یادگیری"
                 )
                 
                 train_btn = gr.Button(
-                    "🤖 شروع آموزش", 
+                    "🤖 شروع آموزش پیشرفته", 
                     variant="primary",
                     size="lg"
                 )
@@ -636,60 +832,65 @@ def create_interface():
                 training_status = gr.Textbox(
                     label="وضعیت آموزش",
                     interactive=False,
-                    placeholder="وضعیت آموزش اینجا نمایش داده می‌شود...",
                     lines=3
                 )
         
         with gr.Row():
-            gr.Markdown("## 🧠 معماری هوش مصنوعی")
+            gr.Markdown("## 🧠 معماری هوش مصنوعی پیشرفته")
             
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Markdown("""
-                **🎯 CNN (پردازش بصری):**
+                **🎯 تحلیل احساسات توئییت:**
+                - آنالیز توئییت‌های ۸ فرد تاثیرگذار
+                - استفاده از ۵ مدل مختلف sentiment analysis
+                - تشخیص فوریت و کلمات کلیدی
+                - وزن‌دهی بر اساس اعتبار افراد
+                
+                **🖼️ CNN (پردازش بصری):**
                 - تحلیل تصاویر نمودارهای قیمت
                 - تشخیص الگوهای تکنیکال
                 - استخراج ویژگی‌های بصری
                 - ورودی: تصاویر 84x84 پیکسل
-                
-                **🤖 Reinforcement Learning:**
-                - الگوریتم Deep Q-Network (DQN)
-                - یادگیری از طریق تعامل با محیط
-                - بهینه‌سازی تصمیم‌های معاملاتی
-                - تجربه replay برای یادگیری پایدار
                 """)
             
             with gr.Column(scale=1):
                 gr.Markdown("""
-                **🎮 اقدامات ممکن:**
-                - **Hold (0)**: حفظ وضعیت فعلی
-                - **Buy (1)**: باز کردن پوزیشن خرید
-                - **Sell (2)**: افزایش سایز پوزیشن
-                - **Close (3)**: بستن پوزیشن فعلی
+                **🤖 Reinforcement Learning:**
+                - الگوریتم Deep Q-Network پیشرفته
+                - ترکیب داده‌های بصری و احساساتی
+                - یادگیری از طریق تعامل با محیط
+                - تجربه replay برای یادگیری پایدار
                 
-                **📈 معیارهای عملکرد:**
-                - **Reward**: امتیاز دریافتی از محیط
-                - **Net Worth**: ارزش کل پرتفولیو
-                - **Balance**: موجودی نقدی
+                **📊 افراد تاثیرگذار تحت نظر:**
+                - Elon Musk, CZ Binance, Michael Saylor
+                - Peter Brandt, Nic Carter, Andreas Antonopoulos
+                - و سایر متخصصان بازار
                 """)
         
         # Event handlers
         init_btn.click(
             demo.initialize_environment,
-            inputs=[initial_balance, risk_level, asset_type],
+            inputs=[initial_balance, risk_level, asset_type, use_sentiment, sentiment_influence],
             outputs=[init_status]
         )
         
         step_btn.click(
             demo.run_single_step,
             inputs=[action_choice],
-            outputs=[price_chart, performance_chart, action_chart, status_output]
+            outputs=[price_chart, performance_chart, action_chart, sentiment_chart, status_output]
         )
         
         episode_btn.click(
             demo.run_episode,
             inputs=[],
-            outputs=[price_chart, performance_chart, action_chart, status_output]
+            outputs=[price_chart, performance_chart, action_chart, sentiment_chart, status_output]
+        )
+        
+        sentiment_btn.click(
+            demo.get_sentiment_analysis_report,
+            inputs=[],
+            outputs=[status_output]
         )
         
         train_btn.click(
@@ -699,45 +900,41 @@ def create_interface():
         )
         
         gr.Markdown("""
-        ## 🏗 جزئیات فنی
-        
-        **🎯 هسته هوش مصنوعی:**
-        - **پردازش بصری**: شبکه عصبی کانولوشن (CNN) با 3 لایه
-        - **یادگیری تقویتی**: الگوریتم Deep Q-Network (DQN)
-        - **تجربه replay**: حافظه 500 نمونه برای یادگیری پایدار
-        - **اکتشاف**: epsilon-greedy با decay پیشرونده
-        
-        **🛠 فناوری‌ها:**
-        - **یادگیری عمیق**: PyTorch
-        - **محیط شبیه‌سازی**: Gymnasium
-        - **رابط کاربری**: Gradio
-        - **ویژوالیزیشن**: Plotly, Matplotlib
-        - **پردازش تصویر**: PIL, OpenCV
-        
-        **📊 ویژگی‌های کلیدی:**
-        - تحلیل بصری نمودارهای قیمت با CNN
-        - یادگیری خودکار استراتژی‌های معاملاتی با RL
-        - نمایش زنده عملکرد و تصمیم‌ها
-        - کنترل دستی و خودکار
-        - آنالیز جامع عملکرد
-        
-        *توسعه داده شده توسط Omid Sakaki - 2024*
+        ## 🏗 جزئیات فنی پیشرفته
+        
+        **🎯 ترکیب سه تکنولوژی:**
+        - **تحلیل احساسات**: ۵ مدل مختلف + VADER + TextBlob
+        - **پردازش بصری**: CNN با ۳ لایه کانولوشن
+        - **یادگیری تقویتی**: DQN پیشرفته با تجربه replay
+        
+        **🛠 فناوری‌های به کار رفته:**
+        - **Transformers**: Hugging Face برای تحلیل احساسات
+        - **PyTorch**: پیاده‌سازی CNN و RL
+        - **Gradio**: رابط کاربری پیشرفته
+        - **Plotly**: ویژوالیزیشن حرفه‌ای
+        
+        **📊 افراد تاثیرگذار تحت نظر:**
+        - Elon Musk (تاثیر: ۹۰٪) - همه بازارها
+        - CZ Binance (تاثیر: ۸۰٪) - بازار کریپتو
+        - Michael Saylor (تاثیر: ۷۰٪) - بیت‌کوین
+        - و ۵ فرد تاثیرگذار دیگر
+        
+        *سیستم حرفه‌ای توسعه داده شده توسط Omid Sakaki - 2024*
         """)
     
     return interface
 
 # Create and launch interface
 if __name__ == "__main__":
-    print("🚀 Starting Visual Trading AI Application...")
-    print("📊 Initializing components...")
+    print("🚀 Starting Professional Trading AI Application...")
+    print("🧠 Loading: Sentiment Analysis + CNN + Reinforcement Learning...")
     
     interface = create_interface()
     
-    print("✅ Application initialized successfully!")
+    print("✅ All components initialized successfully!")
     print("🌐 Starting server on http://0.0.0.0:7860")
-    print("📱 You can now access the application in your browser")
+    print("📱 Access the professional trading AI in your browser")
     
-    # Launch with better configuration
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,