Update app.py

app.py

@@ -37,7 +37,10 @@ with open('src/visualizers/__init__.py', 'w') as f:
 with open('src/utils/__init__.py', 'w') as f:
     f.write('')
 
-# Now import our modules
+# Now import our custom modules
+sys.path.append('src')
+
+# Import our custom modules
 from src.environments.visual_trading_env import VisualTradingEnvironment
 from src.agents.visual_agent import VisualTradingAgent
 
@@ -50,6 +53,16 @@ class ChartRenderer:
         """Render price chart with actions"""
         fig = go.Figure()
         
+        if not prices:
+            # Return empty figure if no data
+            fig.update_layout(
+                title="Price Chart - No Data",
+                xaxis_title="Time Step",
+                yaxis_title="Price",
+                height=300
+            )
+            return fig
+        
         # Add price line
         fig.add_trace(go.Scatter(
             x=list(range(len(prices))),
@@ -71,7 +84,7 @@ class ChartRenderer:
                     y=[prices[i] for i in buy_indices],
                     mode='markers',
                     name='Buy',
-                    marker=dict(color='green', size=10, symbol='triangle-up')
+                    marker=dict(color='green', size=10, symbol='triangle-up', line=dict(width=2, color='darkgreen'))
                 ))
             
             if sell_indices:
@@ -80,14 +93,24 @@ class ChartRenderer:
                     y=[prices[i] for i in sell_indices],
                     mode='markers',
                     name='Sell',
-                    marker=dict(color='red', size=10, symbol='triangle-down')
+                    marker=dict(color='red', size=10, 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=8, symbol='x', line=dict(width=2, color='darkorange'))
                 ))
         
         fig.update_layout(
             title=f"Price Chart (Step: {current_step})",
             xaxis_title="Time Step",
             yaxis_title="Price",
-            height=300
+            height=300,
+            showlegend=True
         )
         
         return fig
@@ -103,9 +126,11 @@ class DataLoader:
         
         prices = [100.0]
         for i in range(1, num_points):
-            # Random walk with trend
+            # Random walk with trend and some mean reversion
             change = np.random.normal(trend, volatility)
-            price = max(0.1, prices[-1] * (1 + change))
+            # Add some mean reversion
+            mean_reversion = (100 - prices[-1]) * 0.001
+            price = max(1.0, prices[-1] * (1 + change) + mean_reversion)
             prices.append(price)
         
         return np.array(prices)
@@ -129,91 +154,131 @@ class TradingAIDemo:
         self.episode_history = []
         self.chart_renderer = ChartRenderer()
         self.data_loader = DataLoader()
+        self.initialized = False
         
     def initialize_environment(self, initial_balance, risk_level, asset_type):
         """Initialize trading environment"""
         try:
+            print(f"Initializing environment with balance: {initial_balance}, risk: {risk_level}, asset: {asset_type}")
+            
             self.env = VisualTradingEnvironment(
-                initial_balance=initial_balance,
+                initial_balance=float(initial_balance),
                 risk_level=risk_level,
                 asset_type=asset_type
             )
+            
+            # Initialize agent with correct dimensions
             self.agent = VisualTradingAgent(
-                state_dim=(84, 84, 4),
+                state_dim=(84, 84, 4),  # Fixed dimensions
                 action_dim=4
             )
+            
             self.current_state = self.env.reset()
             self.episode_history = []
-            return "✅ Environment initialized successfully!"
+            self.initialized = True
+            
+            return "✅ Environment initialized successfully! Ready for trading."
+            
         except Exception as e:
-            return f"❌ Error initializing environment: {str(e)}"
+            error_msg = f"❌ Error initializing environment: {str(e)}"
+            print(error_msg)
+            return error_msg
     
     def run_single_step(self, action_choice):
         """Run a single step in the environment"""
-        if self.env is None or self.agent is None:
-            return None, None, "Please initialize environment first!"
+        if not self.initialized or self.env is None or self.agent is None:
+            return None, None, None, "⚠️ Please initialize environment first!"
         
         try:
             # Use selected action or let agent decide
             if action_choice == "AI Decision":
                 action = self.agent.select_action(self.current_state)
+                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})")
             
             # Execute action
             next_state, reward, done, info = self.env.step(action)
             self.current_state = next_state
             
             # Update history
-            self.episode_history.append({
+            history_entry = {
                 'step': len(self.episode_history),
                 'action': action,
                 'reward': reward,
                 'net_worth': info['net_worth'],
                 'balance': info['balance'],
                 'position': info['position_size'],
-                'price': info['current_price']
-            })
+                'price': info['current_price'],
+                'action_source': action_source
+            }
+            self.episode_history.append(history_entry)
             
             # Create visualizations
             price_chart = self.create_price_chart(info)
             performance_chart = self.create_performance_chart()
             action_chart = self.create_action_chart()
             
-            status = f"Step {info['step']}: {['Hold', 'Buy', 'Sell', 'Close'][action]} | Reward: {reward:.3f} | Net Worth: ${info['net_worth']:.2f}"
+            # Create status message
+            action_names = ["Hold", "Buy", "Sell", "Close"]
+            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}"
+            )
+            
             if done:
-                status += " | Episode Completed!"
+                status += "\n🎯 Episode Completed!"
             
             return price_chart, performance_chart, action_chart, status
             
         except Exception as e:
-            return None, None, None, f"❌ Error during step: {str(e)}"
+            error_msg = f"❌ Error during step execution: {str(e)}"
+            print(error_msg)
+            return None, None, None, error_msg
     
-    def run_episode(self, num_steps):
+    def run_episode(self, num_steps=20):
         """Run a complete episode"""
-        if self.env is None or self.agent is None:
-            return None, None, None, "Please initialize environment first!"
+        if not self.initialized or self.env is None or self.agent is None:
+            return None, None, None, "⚠️ Please initialize environment first!"
         
         try:
-            self.env.reset()
+            # Reset environment for new episode
+            self.current_state = self.env.reset()
             self.episode_history = []
             total_reward = 0
             
+            print(f"Starting episode with {num_steps} steps...")
+            
             for step in range(num_steps):
                 action = self.agent.select_action(self.current_state)
                 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)
+                
                 self.episode_history.append({
                     'step': step,
                     'action': action,
                     'reward': reward,
                     'net_worth': info['net_worth'],
-                    'price': info['current_price']
+                    'price': info['current_price'],
+                    'action_source': 'AI'
                 })
                 
+                # Small delay to make execution visible
+                time.sleep(0.05)
+                
                 if done:
                     break
             
@@ -222,30 +287,44 @@ class TradingAIDemo:
             performance_chart = self.create_performance_chart()
             action_chart = self.create_action_chart()
             
-            summary = f"Episode completed! Total Reward: {total_reward:.2f} | Final Net Worth: ${info['net_worth']:.2f} | Steps: {len(self.episode_history)}"
+            # Calculate performance metrics
+            initial_balance = self.env.initial_balance
+            final_net_worth = info['net_worth']
+            total_return = (final_net_worth - initial_balance) / initial_balance * 100
+            
+            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"• Total Trades: {info['total_trades']}"
+            )
             
             return price_chart, performance_chart, action_chart, summary
             
         except Exception as e:
-            return None, None, None, f"❌ Error during episode: {str(e)}"
+            error_msg = f"❌ Error during episode: {str(e)}"
+            print(error_msg)
+            return None, None, None, error_msg
     
     def train_agent(self, num_episodes, learning_rate):
         """Train the AI agent"""
-        if self.env is None:
-            yield None, None, None, "Please initialize environment first!"
+        if not self.initialized or self.env is None:
+            yield None, "⚠️ Please initialize environment first!"
             return
         
         self.is_training = True
         training_history = []
         
         try:
-            for episode in range(num_episodes):
+            for episode in range(int(num_episodes)):
                 state = self.env.reset()
                 episode_reward = 0
                 done = False
                 steps = 0
                 
-                while not done and steps < 200:  # Limit steps per episode
+                while not done and steps < 100:  # Limit steps per episode
                     action = self.agent.select_action(state)
                     next_state, reward, done, info = self.env.step(action)
                     self.agent.store_transition(state, action, reward, next_state, done)
@@ -260,28 +339,52 @@ class TradingAIDemo:
                     'episode': episode,
                     'reward': episode_reward,
                     'net_worth': info['net_worth'],
-                    'loss': loss if loss else 0
+                    'loss': loss if loss else 0,
+                    'steps': steps
                 })
                 
-                # Yield progress every 10 episodes or at the end
-                if episode % 10 == 0 or episode == num_episodes - 1:
+                # Yield progress every 5 episodes or at the end
+                if episode % 5 == 0 or episode == num_episodes - 1:
                     progress_chart = self.create_training_progress(training_history)
-                    yield progress_chart, f"Training... Episode {episode+1}/{num_episodes} (Reward: {episode_reward:.2f})"
+                    status = (
+                        f"🔄 Training Progress: {episode+1}/{num_episodes}\n"
+                        f"• Episode Reward: {episode_reward:.2f}\n"
+                        f"• Final Net Worth: ${info['net_worth']:.2f}\n"
+                        f"• Loss: {loss:.4f if loss else 0:.4f}\n"
+                        f"• Epsilon: {self.agent.epsilon:.3f}"
+                    )
+                    yield progress_chart, status
                 
                 # Small delay to make training visible
                 time.sleep(0.01)
             
             self.is_training = False
-            yield self.create_training_progress(training_history), "✅ Training completed!"
+            final_status = (
+                f"✅ Training Completed!\n"
+                f"• Total Episodes: {num_episodes}\n"
+                f"• Final Epsilon: {self.agent.epsilon:.3f}\n"
+                f"• Average Reward: {np.mean([h['reward'] for h in training_history]):.2f}"
+            )
+            yield self.create_training_progress(training_history), final_status
             
         except Exception as e:
             self.is_training = False
-            yield None, f"❌ Training error: {str(e)}"
+            error_msg = f"❌ Training error: {str(e)}"
+            print(error_msg)
+            yield None, error_msg
     
     def create_price_chart(self, info):
         """Create price chart with actions"""
         if not self.episode_history:
-            return go.Figure()
+            # Return empty chart with message
+            fig = go.Figure()
+            fig.update_layout(
+                title="Price Chart - No Data Available",
+                xaxis_title="Time Step",
+                yaxis_title="Price",
+                height=300
+            )
+            return fig
         
         prices = [h['price'] for h in self.episode_history]
         actions = [h['action'] for h in self.episode_history]
@@ -294,7 +397,7 @@ class TradingAIDemo:
             y=prices,
             mode='lines',
             name='Price',
-            line=dict(color='blue', width=2)
+            line=dict(color='blue', width=3)
         ))
         
         # Action markers
@@ -308,7 +411,8 @@ class TradingAIDemo:
                 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'))
+                marker=dict(color='green', size=12, symbol='triangle-up', 
+                          line=dict(width=2, color='darkgreen'))
             ))
         
         if sell_indices:
@@ -317,7 +421,8 @@ class TradingAIDemo:
                 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'))
+                marker=dict(color='red', size=12, symbol='triangle-down', 
+                          line=dict(width=2, color='darkred'))
             ))
         
         if close_indices:
@@ -326,15 +431,17 @@ class TradingAIDemo:
                 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'))
+                marker=dict(color='orange', size=10, symbol='x', 
+                          line=dict(width=2, color='darkorange'))
             ))
         
         fig.update_layout(
             title="Price Chart with Trading Actions",
             xaxis_title="Step",
             yaxis_title="Price",
-            height=300,
-            showlegend=True
+            height=350,
+            showlegend=True,
+            template="plotly_white"
         )
         
         return fig
@@ -342,35 +449,48 @@ class TradingAIDemo:
     def create_performance_chart(self):
         """Create portfolio performance chart"""
         if not self.episode_history:
-            return go.Figure()
+            fig = go.Figure()
+            fig.update_layout(
+                title="Portfolio Performance - No Data Available",
+                height=400
+            )
+            return fig
         
         net_worth = [h['net_worth'] for h in self.episode_history]
         rewards = [h['reward'] for h in self.episode_history]
         
         fig = make_subplots(
             rows=2, cols=1,
-            subplot_titles=['Portfolio Value', 'Step Rewards'],
-            vertical_spacing=0.1
+            subplot_titles=['Portfolio Value Over Time', 'Step Rewards'],
+            vertical_spacing=0.15
         )
         
         # Portfolio value
         fig.add_trace(go.Scatter(
             x=list(range(len(net_worth))),
             y=net_worth,
-            mode='lines',
+            mode='lines+markers',
             name='Net Worth',
-            line=dict(color='green', width=2)
+            line=dict(color='green', width=3),
+            marker=dict(size=4)
         ), row=1, col=1)
         
-        # Rewards
+        # Add initial balance reference line
+        if self.env:
+            fig.add_hline(y=self.env.initial_balance, line_dash="dash", 
+                         line_color="red", annotation_text="Initial Balance",
+                         row=1, col=1)
+        
+        # Rewards as bar chart
         fig.add_trace(go.Bar(
             x=list(range(len(rewards))),
             y=rewards,
             name='Reward',
-            marker_color=['green' if r >= 0 else 'red' for r in rewards]
+            marker_color=['green' if r >= 0 else 'red' for r in rewards],
+            opacity=0.7
         ), row=2, col=1)
         
-        fig.update_layout(height=400, showlegend=False)
+        fig.update_layout(height=500, showlegend=False, template="plotly_white")
         fig.update_yaxes(title_text="Value ($)", row=1, col=1)
         fig.update_yaxes(title_text="Reward", row=2, col=1)
         fig.update_xaxes(title_text="Step", row=2, col=1)
@@ -380,7 +500,12 @@ class TradingAIDemo:
     def create_action_chart(self):
         """Create action distribution chart"""
         if not self.episode_history:
-            return go.Figure()
+            fig = go.Figure()
+            fig.update_layout(
+                title="Action Distribution - No Data Available",
+                height=300
+            )
+            return fig
         
         actions = [h['action'] for h in self.episode_history]
         action_names = ['Hold', 'Buy', 'Sell', 'Close']
@@ -391,13 +516,16 @@ class TradingAIDemo:
         fig = go.Figure(data=[go.Pie(
             labels=action_names,
             values=action_counts,
-            hole=.3,
-            marker_colors=colors
+            hole=.4,
+            marker_colors=colors,
+            textinfo='label+percent+value',
+            hoverinfo='label+percent+value'
         )])
         
         fig.update_layout(
             title="Action Distribution",
-            height=300
+            height=350,
+            annotations=[dict(text='Actions', x=0.5, y=0.5, font_size=16, showarrow=False)]
         )
         
         return fig
@@ -405,45 +533,65 @@ class TradingAIDemo:
     def create_training_progress(self, training_history):
         """Create training progress visualization"""
         if not training_history:
-            return go.Figure()
+            fig = go.Figure()
+            fig.update_layout(
+                title="Training Progress - No Data Available",
+                height=500
+            )
+            return fig
         
         df = pd.DataFrame(training_history)
         
         fig = make_subplots(
             rows=2, cols=2,
             subplot_titles=['Episode Rewards', 'Portfolio Value',
-                          'Training Loss', 'Moving Average (10)'],
+                          'Training Loss', 'Moving Average Reward (5)'],
             specs=[[{}, {}], [{}, {}]]
         )
         
         # Rewards
         fig.add_trace(go.Scatter(
             x=df['episode'], y=df['reward'], mode='lines+markers',
-            name='Reward', line=dict(color='blue')
+            name='Reward', line=dict(color='blue', width=2),
+            marker=dict(size=4)
         ), row=1, col=1)
         
         # Portfolio value
         fig.add_trace(go.Scatter(
             x=df['episode'], y=df['net_worth'], mode='lines+markers',
-            name='Net Worth', line=dict(color='green')
+            name='Net Worth', line=dict(color='green', width=2),
+            marker=dict(size=4)
         ), row=1, col=2)
         
+        # Add initial balance reference
+        if self.env:
+            fig.add_hline(y=self.env.initial_balance, line_dash="dash", 
+                         line_color="red", annotation_text="Initial Balance",
+                         row=1, col=2)
+        
         # Loss
-        if 'loss' in df.columns and df['loss'].notna().any():
+        if 'loss' in df.columns and df['loss'].notna().any() and df['loss'].sum() > 0:
             fig.add_trace(go.Scatter(
                 x=df['episode'], y=df['loss'], mode='lines+markers',
-                name='Loss', line=dict(color='red')
+                name='Loss', line=dict(color='red', width=2),
+                marker=dict(size=4)
             ), row=2, col=1)
         
         # Moving average reward
-        if len(df) > 10:
-            df['ma_reward'] = df['reward'].rolling(window=10).mean()
+        if len(df) > 5:
+            df['ma_reward'] = df['reward'].rolling(window=5).mean()
             fig.add_trace(go.Scatter(
                 x=df['episode'], y=df['ma_reward'], mode='lines',
-                name='MA Reward (10)', line=dict(color='orange', dash='dash')
+                name='MA Reward (5)', line=dict(color='orange', width=3, dash='dash')
             ), row=2, col=2)
         
-        fig.update_layout(height=500, showlegend=True, title_text="Training Progress")
+        fig.update_layout(
+            height=600, 
+            showlegend=True, 
+            title_text="Training Progress Over Episodes",
+            template="plotly_white"
+        )
+        
         return fig
 
 # Initialize the demo
@@ -454,79 +602,174 @@ def create_interface():
     with gr.Blocks(theme=gr.themes.Soft(), title="Visual Trading AI") as interface:
         gr.Markdown("""
         # 🚀 Visual Trading AI
-        *Intelligent Trading Agent with Visual Market Analysis*
+        **هوش مصنوعی معامله‌گر بصری - تحلیل چارت‌های قیمت با یادگیری تقویتی عمیق**
         
-        This AI agent learns to trade by analyzing price charts visually using Deep Reinforcement Learning.
+        *این پروژه از شبکه‌های عصبی کانولوشن برای تحلیل بصری نمودارهای قیمت و یادگیری تقویتی برای تصمیم‌گیری معاملاتی استفاده می‌کند.*
         """)
         
         with gr.Row():
             with gr.Column(scale=1):
                 # Configuration section
-                gr.Markdown("## ⚙️ Configuration")
+                gr.Markdown("## ⚙️ پیکربندی محیط")
+                
+                with gr.Row():
+                    initial_balance = gr.Slider(
+                        minimum=1000, maximum=50000, value=10000, step=1000,
+                        label="موجودی اولیه ($)", info="میزان سرمایه اولیه برای معامله"
+                    )
+                
+                with gr.Row():
+                    risk_level = gr.Radio(
+                        ["Low", "Medium", "High"], 
+                        value="Medium",
+                        label="سطح ریسک",
+                        info="سطح ریسک پذیری در معاملات"
+                    )
                 
                 with gr.Row():
-                    initial_balance = gr.Slider(1000, 50000, value=10000, step=1000, 
-                                              label="Initial Balance ($)")
+                    asset_type = gr.Radio(
+                        ["Stock", "Crypto", "Forex"], 
+                        value="Stock",
+                        label="نوع دارایی",
+                        info="نوع بازار مالی برای شبیه‌سازی"
+                    )
                 
                 with gr.Row():
-                    risk_level = gr.Radio(["Low", "Medium", "High"], value="Medium",
-                                        label="Risk Level")
-                    asset_type = gr.Radio(["Stock", "Crypto", "Forex"], value="Stock",
-                                        label="Asset Type")
+                    init_btn = gr.Button(
+                        "🚀 راه‌اندازی محیط معاملاتی", 
+                        variant="primary",
+                        size="lg"
+                    )
                 
-                init_btn = gr.Button("🚀 Initialize Environment", variant="primary", scale=1)
-                init_status = gr.Textbox(label="Status", interactive=False, scale=1)
+                with gr.Row():
+                    init_status = gr.Textbox(
+                        label="وضعیت راه‌اندازی",
+                        interactive=False,
+                        placeholder="برای شروع، محیط را راه‌اندازی کنید...",
+                        lines=2
+                    )
             
             with gr.Column(scale=2):
                 # Status output
-                status_output = gr.Textbox(label="Trading Status", interactive=False)
+                gr.Markdown("## 📊 وضعیت معاملات")
+                status_output = gr.Textbox(
+                    label="وضعیت اجرا",
+                    interactive=False,
+                    placeholder="وضعیت معاملات اینجا نمایش داده می‌شود...",
+                    lines=4
+                )
         
+        with gr.Row():
+            gr.Markdown("## 🎮 کنترل معاملات")
+            
         with gr.Row():
             # Action controls
-            action_choice = gr.Radio(["AI Decision", "Buy", "Sell", "Hold", "Close"],
-                                   value="AI Decision", label="Action Selection")
+            action_choice = gr.Radio(
+                ["AI Decision", "Buy", "Sell", "Hold", "Close"],
+                value="AI Decision",
+                label="انتخاب اقدام",
+                info="AI Decision: تصمیم خودکار هوش مصنوعی"
+            )
             
+        with gr.Row():
             with gr.Column(scale=1):
-                step_btn = gr.Button("▶️ Execute Single Step", variant="secondary")
-                episode_btn = gr.Button("🎯 Run Episode (20 steps)", variant="secondary")
+                step_btn = gr.Button(
+                    "▶️ اجرای یک قدم", 
+                    variant="secondary",
+                    size="lg"
+                )
+            
+            with gr.Column(scale=1):
+                episode_btn = gr.Button(
+                    "🎯 اجرای یک اپیزود (20 قدم)", 
+                    variant="secondary",
+                    size="lg"
+                )
         
         with gr.Row():
             # Visualization outputs
-            price_chart = gr.Plot(label="Price & Actions")
-            performance_chart = gr.Plot(label="Portfolio Performance")
-            action_chart = gr.Plot(label="Action Distribution")
+            with gr.Column(scale=1):
+                price_chart = gr.Plot(
+                    label="📈 نمودار قیمت و اقدامات"
+                )
+            
+            with gr.Column(scale=1):
+                performance_chart = gr.Plot(
+                    label="💰 عملکرد پرتفولیو"
+                )
         
         with gr.Row():
-            # Training section
-            gr.Markdown("## 🎓 AI Training")
+            with gr.Column(scale=1):
+                action_chart = gr.Plot(
+                    label="🎯 توزیع اقدامات"
+                )
+        
+        with gr.Row():
+            gr.Markdown("## 🎓 آموزش هوش مصنوعی")
             
-            with gr.Column():
-                num_episodes = gr.Slider(10, 500, value=50, step=10,
-                                       label="Training Episodes")
-                learning_rate = gr.Slider(0.0001, 0.01, value=0.001, step=0.0001,
-                                        label="Learning Rate")
-                train_btn = gr.Button("🤖 Start Training", variant="primary")
+        with gr.Row():
+            with gr.Column(scale=1):
+                num_episodes = gr.Slider(
+                    minimum=10, maximum=200, value=50, step=10,
+                    label="تعداد اپیزودهای آموزش",
+                    info="تعداد دوره‌های آموزشی"
+                )
+                
+                learning_rate = gr.Slider(
+                    minimum=0.0001, maximum=0.01, value=0.001, step=0.0001,
+                    label="نرخ یادگیری",
+                    info="سرعت یادگیری الگوریتم"
+                )
+                
+                train_btn = gr.Button(
+                    "🤖 شروع آموزش", 
+                    variant="primary",
+                    size="lg"
+                )
             
-            with gr.Column():
-                training_plot = gr.Plot(label="Training Progress")
-                training_status = gr.Textbox(label="Training Status")
+            with gr.Column(scale=2):
+                training_plot = gr.Plot(
+                    label="📊 پیشرفت آموزش"
+                )
+                
+                training_status = gr.Textbox(
+                    label="وضعیت آموزش",
+                    interactive=False,
+                    placeholder="وضعیت آموزش اینجا نمایش داده می‌شود...",
+                    lines=3
+                )
         
         with gr.Row():
-            # Information section
-            gr.Markdown("## 📊 System Information")
-            gr.Markdown("""
-            **How it works:**
-            - The AI analyzes price charts visually using a CNN
-            - Reinforcement learning optimizes trading decisions
-            - Real-time visualization shows agent behavior
-            - Training improves performance over time
-            
-            **Action Types:**
-            - 🟦 Hold: Maintain current position
-            - 🟩 Buy: Open long position  
-            - 🟥 Sell: Increase position size
-            - 🟧 Close: Close current position
-            """)
+            gr.Markdown("## ℹ️ راهنمای استفاده")
+            
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("""
+                **🎯 اقدامات ممکن:**
+                - **Hold (0)**: حفظ وضعیت فعلی
+                - **Buy (1)**: باز کردن پوزیشن خرید
+                - **Sell (2)**: افزایش سایز پوزیشن
+                - **Close (3)**: بستن پوزیشن فعلی
+                
+                **📈 معیارهای عملکرد:**
+                - **Reward**: امتیاز دریافتی از محیط
+                - **Net Worth**: ارزش کل پرتفولیو
+                - **Balance**: موجودی نقدی
+                - **Position**: سایز پوزیشن فعلی
+                """)
+            
+            with gr.Column(scale=1):
+                gr.Markdown("""
+                **🔧 نحوه استفاده:**
+                1. محیط را راه‌اندازی کنید
+                2. اقدامات تکی یا اپیزودها را اجرا کنید
+                3. عملکرد را در نمودارها مشاهده کنید
+                4. هوش مصنوعی را آموزش دهید
+                5. نتایج را تحلیل کنید
+                
+                **⚠️ توجه:**
+                این یک شبیه‌ساز آموزشی است و برای معاملات واقعی طراحی نشده است.
+                """)
         
         # Event handlers
         init_btn.click(
@@ -542,7 +785,8 @@ def create_interface():
         )
         
         episode_btn.click(
-            lambda: demo.run_episode(20),
+            demo.run_episode,
+            inputs=[],
             outputs=[price_chart, performance_chart, action_chart, status_output]
         )
         
@@ -553,25 +797,48 @@ def create_interface():
         )
         
         gr.Markdown("""
-        ## 🔧 Technical Details
-        
-        **Architecture:**
-        - **Visual Processing**: CNN analyzes price charts as images
-        - **Reinforcement Learning**: Deep Q-Network for decision making
-        - **Real-time Visualization**: Plotly for interactive charts
-        
-        **Technology Stack:**
-        - PyTorch for deep learning
-        - Gymnasium for environment
-        - Gradio for web interface
-        - Plotly for visualization
-        
-        *Note: This is a demonstration with synthetic data. Not for real trading.*
+        ## 🏗 معماری فنی
+        
+        **🎯 هسته هوش مصنوعی:**
+        - **پردازش بصری**: شبکه عصبی کانولوشن (CNN) برای تحلیل نمودارهای قیمت
+        - **یادگیری تقویتی**: الگوریتم Deep Q-Network (DQN) برای تصمیم‌گیری
+        - **تجربه replay**: ذخیره و بازیابی تجربیات برای یادگیری پایدار
+        
+        **🛠 فناوری‌ها:**
+        - **یادگیری عمیق**: PyTorch
+        - **محیط شبیه‌سازی**: محیط اختصاصی معاملاتی
+        - **رابط کاربری**: Gradio
+        - **ویژوالیزیشن**: Plotly, Matplotlib
+        - **پردازش داده**: NumPy, Pandas
+        
+        **📊 ویژگی‌های کلیدی:**
+        - تحلیل بصری نمودارهای قیمت
+        - یادگیری خودکار استراتژی‌های معاملاتی
+        - نمایش زنده عملکرد و تصمیم‌ها
+        - کنترل دستی و خودکار
+        - آنالیز جامع عملکرد
+        
+        *توسعه داده شده توسط Omid Sakaki - 2024*
         """)
     
     return interface
 
 # Create and launch interface
 if __name__ == "__main__":
+    print("🚀 Starting Visual Trading AI Application...")
+    print("📊 Initializing components...")
+    
     interface = create_interface()
-    interface.launch(share=False)
+    
+    print("✅ Application initialized successfully!")
+    print("🌐 Starting server on http://0.0.0.0:7860")
+    print("📱 You can now access the application in your browser")
+    
+    # Launch with better configuration
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        debug=True
+    )