Update app.py

app.py

@@ -9,113 +9,171 @@ import pickle
 import warnings
 warnings.filterwarnings('ignore')
 
-# Load trained model - USING YOUR SPECIFIC STOCKS
+# Custom unpickler to handle numpy version issues
+class SafeUnpickler(pickle.Unpickler):
+    def find_class(self, module, name):
+        if module == "numpy._core.multiarray" or module == "numpy.core.multiarray":
+            return np.core.multiarray.scalar
+        if module == "numpy":
+            return getattr(np, name)
+        return super().find_class(module, name)
+
 def load_model():
     try:
         with open('portfolio_risk_model.pkl', 'rb') as f:
-            model = pickle.load(f)
+            model = SafeUnpickler(f).load()
         print("✅ Model loaded successfully!")
-        print(f"📊 Model trained on: {model['tickers']}")
         return model
     except Exception as e:
         print(f"❌ Model loading error: {str(e)}")
+        # Create model from scratch using yfinance data
+        return create_model_from_scratch()
+
+def create_model_from_scratch():
+    """Create model directly from yfinance data"""
+    print("🔄 Creating model from scratch...")
+    
+    stocks = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA']
+    
+    try:
+        # Fetch fresh data
+        data = yf.download(stocks, period='5y')['Adj Close']
+        returns = data.pct_change().dropna()
+        
+        # Calculate model parameters
+        mean_returns = returns.mean().tolist()
+        cov_matrix = returns.cov().values.tolist()
+        volatilities = (returns.std() * np.sqrt(252)).tolist()
+        
+        # Calculate portfolio metrics
+        portfolio_returns = returns.dot([0.2, 0.2, 0.2, 0.2, 0.2])
+        
+        model = {
+            'mean_returns': mean_returns,
+            'covariance_matrix': cov_matrix,
+            'volatilities': volatilities,
+            'risk_metrics': {
+                'historical_var_95': float(np.percentile(portfolio_returns, 5)),
+                'cvar_95': float(portfolio_returns[portfolio_returns <= np.percentile(portfolio_returns, 5)].mean()),
+                'annual_mean_return': float(portfolio_returns.mean() * 252),
+                'annual_volatility': float(portfolio_returns.std() * np.sqrt(252)),
+                'sharpe_ratio': float((portfolio_returns.mean() * 252) / (portfolio_returns.std() * np.sqrt(252)))
+            },
+            'loss_probabilities': {
+                'probability_10_percent_loss': 0.15,  # Placeholder
+                'probability_20_percent_loss': 0.08,  # Placeholder
+                'probability_30_percent_loss': 0.03,  # Placeholder
+                'expected_portfolio_value': 110.0,    # Placeholder
+                'median_portfolio_value': 108.5,      # Placeholder
+                'worst_case_5th_percentile': 85.0,    # Placeholder
+                'best_case_95th_percentile': 135.0    # Placeholder
+            },
+            'tickers': stocks,
+            'training_date': datetime.now().strftime("%Y-%m-%d"),
+            'data_period': '5 years'
+        }
+        print("✅ Model created from scratch!")
+        return model
+    except Exception as e:
+        print(f"❌ Error creating model: {str(e)}")
         return None
 
 class GradioRiskApp:
     def __init__(self):
         self.model = load_model()
-        
-        # USE EXACTLY THE SAME 5 STOCKS YOU TRAINED WITH
         self.available_stocks = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA']
-        
-        print(f"🎯 Using trained stocks: {self.available_stocks}")
+        print(f"🎯 Available stocks: {self.available_stocks}")
     
     def run_monte_carlo(self, selected_stocks, days=252, simulations=5000):
-        """Run Monte Carlo simulation using the trained model"""
+        """Run Monte Carlo simulation"""
         try:
             if self.model is None:
-                return "❌ Model not loaded properly", None, None, None
+                print("❌ No model available")
+                return None
             
-            # Check if selected stocks match trained stocks
             if set(selected_stocks) != set(self.available_stocks):
-                return f"❌ Please use exactly these 5 stocks: {self.available_stocks}", None, None, None
+                print("❌ Stocks don't match trained stocks")
+                return None
             
-            n_stocks = len(selected_stocks)
-            print(f"🎯 Running MC simulation for {selected_stocks}...")
+            print("🎯 Running Monte Carlo simulation...")
             
-            # Use the trained model parameters
+            # Extract parameters from model
             mean_returns = np.array(self.model['mean_returns'])
             cov_matrix = np.array(self.model['covariance_matrix'])
             
+            # Ensure covariance matrix is positive definite
+            cov_matrix = self.make_positive_definite(cov_matrix)
+            
             # Generate simulation
             np.random.seed(42)
-            try:
-                L = np.linalg.cholesky(cov_matrix)
-            except:
-                # Use eigenvalue decomposition if Cholesky fails
-                eigvals, eigvecs = np.linalg.eigh(cov_matrix)
-                L = eigvecs @ np.diag(np.sqrt(np.maximum(eigvals, 0)))
+            L = np.linalg.cholesky(cov_matrix)
             
             simulation_results = []
-            equal_weights = np.array([0.2, 0.2, 0.2, 0.2, 0.2])  # Equal weights for 5 stocks
+            weights = np.array([0.2, 0.2, 0.2, 0.2, 0.2])
             
             for i in range(simulations):
-                random_numbers = np.random.normal(0, 1, size=(days, n_stocks))
-                correlated_randoms = random_numbers @ L.T
-                daily_returns = correlated_randoms + mean_returns
+                # Generate correlated returns
+                random_numbers = np.random.normal(0, 1, size=(days, 5))
+                correlated_returns = random_numbers @ L.T + mean_returns
                 
-                portfolio_value = 100
+                # Calculate portfolio path
+                portfolio_value = 100.0
                 portfolio_path = [portfolio_value]
                 
                 for day in range(days):
-                    daily_portfolio_return = np.dot(daily_returns[day], equal_weights)
-                    portfolio_value *= (1 + daily_portfolio_return)
+                    daily_return = np.dot(correlated_returns[day], weights)
+                    portfolio_value = portfolio_value * (1 + daily_return)
                     portfolio_path.append(portfolio_value)
                 
                 simulation_results.append(portfolio_path)
             
-            print(f"✅ Simulation completed: {len(simulation_results)} paths")
-            return simulation_results
+            print(f"✅ Simulation completed with {len(simulation_results)} paths")
+            return np.array(simulation_results)
             
         except Exception as e:
             print(f"❌ Simulation error: {str(e)}")
             return None
     
+    def make_positive_definite(self, matrix):
+        """Ensure covariance matrix is positive definite"""
+        min_eig = np.min(np.real(np.linalg.eigvals(matrix)))
+        if min_eig < 0:
+            matrix -= 10 * min_eig * np.eye(*matrix.shape)
+        return matrix
+    
     def calculate_metrics(self, simulation_results):
-        """Calculate risk metrics from simulation"""
+        """Calculate risk metrics"""
         if simulation_results is None:
             return None
-            
-        simulation_array = np.array(simulation_results)
-        final_values = simulation_array[:, -1]
+        
+        final_values = simulation_results[:, -1]
         
         metrics = {
-            'expected_value': np.mean(final_values),
-            'prob_10_loss': np.mean(final_values < 90),
-            'prob_20_loss': np.mean(final_values < 80),
-            'prob_30_loss': np.mean(final_values < 70),
-            'var_95': np.percentile(final_values, 5),
-            'best_case': np.percentile(final_values, 95),
-            'worst_case': np.percentile(final_values, 5),
-            'median_value': np.median(final_values)
+            'expected_value': float(np.mean(final_values)),
+            'prob_10_loss': float(np.mean(final_values < 90)),
+            'prob_20_loss': float(np.mean(final_values < 80)),
+            'prob_30_loss': float(np.mean(final_values < 70)),
+            'var_95': float(np.percentile(final_values, 5)),
+            'best_case': float(np.percentile(final_values, 95)),
+            'worst_case': float(np.percentile(final_values, 5))
         }
         
-        return metrics, simulation_array
+        return metrics
     
     def create_simulation_plot(self, simulation_results):
-        """Create Monte Carlo simulation plot"""
+        """Create simulation plot"""
         if simulation_results is None:
             return None
-            
+        
         fig = go.Figure()
         
-        # Show only 30 paths for clarity
-        for i in range(min(30, len(simulation_results))):
+        # Sample paths
+        for i in range(min(50, len(simulation_results))):
             fig.add_trace(go.Scatter(
                 y=simulation_results[i],
                 mode='lines',
                 line=dict(width=1, color='lightblue'),
-                opacity=0.3,
+                opacity=0.1,
                 showlegend=False
             ))
         
@@ -132,272 +190,167 @@ class GradioRiskApp:
             title="📈 Monte Carlo Simulation Paths",
             xaxis_title="Trading Days",
             yaxis_title="Portfolio Value ($)",
-            height=400,
-            showlegend=True
+            height=400
         )
         
         return fig
     
     def create_distribution_plot(self, simulation_results, metrics):
-        """Create final value distribution plot"""
+        """Create distribution plot"""
         if simulation_results is None:
             return None
-            
-        final_values = np.array(simulation_results)[:, -1]
+        
+        final_values = simulation_results[:, -1]
         
         fig = px.histogram(
             x=final_values,
             nbins=50,
-            title="📊 Distribution of Final Portfolio Values",
-            color_discrete_sequence=['#FF6B6B']
+            title="📊 Portfolio Value Distribution",
+            color_discrete_sequence=['#667eea']
         )
         
         if metrics:
-            fig.add_vline(x=metrics['expected_value'], line_dash="dash", line_color="red",
-                         annotation_text=f"Mean: ${metrics['expected_value']:.2f}")
-            fig.add_vline(x=metrics['var_95'], line_dash="dash", line_color="orange",
-                         annotation_text=f"Worst 5%: ${metrics['var_95']:.2f}")
+            fig.add_vline(x=metrics['expected_value'], line_dash="dash", 
+                         line_color="red", annotation_text=f"Mean: ${metrics['expected_value']:.2f}")
+            fig.add_vline(x=metrics['var_95'], line_dash="dash", 
+                         line_color="orange", annotation_text=f"5% VaR: ${metrics['var_95']:.2f}")
         
         fig.update_layout(height=400, showlegend=False)
         return fig
     
     def create_risk_gauge(self, metrics):
-        """Create risk probability gauge"""
+        """Create risk gauge"""
         if metrics is None:
             return None
-            
+        
         risk_prob = metrics['prob_10_loss'] * 100
         
         fig = go.Figure(go.Indicator(
-            mode = "gauge+number",
-            value = risk_prob,
-            domain = {'x': [0, 1], 'y': [0, 1]},
-            title = {'text': "🔴 Probability of >10% Loss"},
-            gauge = {
-                'axis': {'range': [None, 50]},
-                'bar': {'color': "darkred"},
+            mode="gauge+number",
+            value=risk_prob,
+            domain={'x': [0, 1], 'y': [0, 1]},
+            title={'text': "Probability of >10% Loss"},
+            gauge={
+                'axis': {'range': [0, 50]},
+                'bar': {'color': "darkblue"},
                 'steps': [
                     {'range': [0, 15], 'color': "lightgreen"},
                     {'range': [15, 30], 'color': "yellow"},
-                    {'range': [30, 50], 'color': "red"}],
-                'threshold': {
-                    'line': {'color': "black", 'width': 4},
-                    'thickness': 0.75,
-                    'value': 25}}
+                    {'range': [30, 50], 'color': "red"}
+                ]
+            }
         ))
         fig.update_layout(height=300)
         return fig
     
     def analyze_portfolio(self, selected_stocks, simulation_days, num_simulations):
         """Main analysis function"""
-        print(f"🔍 Analyzing portfolio: {selected_stocks}")
+        print(f"🔍 Analyzing: {selected_stocks}")
         
         if not selected_stocks:
-            error_html = """
-            <div style='text-align: center; padding: 50px; background: #fff3cd; border-radius: 10px;'>
-                <h3 style='color: #856404;'>⚠️ Please Select Stocks</h3>
-                <p>Choose at least one stock from the list to run the analysis.</p>
-            </div>
-            """
-            return error_html, None, None, None
+            return self.create_error_html("Please select at least one stock"), None, None, None
         
-        # Check if user selected exactly the 5 trained stocks
         if set(selected_stocks) != set(self.available_stocks):
-            error_html = f"""
-            <div style='text-align: center; padding: 50px; background: #fff3cd; border-radius: 10px;'>
-                <h3 style='color: #856404;'>⚠️ Use Trained Stocks Only</h3>
-                <p>This model was trained specifically on these 5 stocks:</p>
-                <p style='font-weight: bold; font-size: 18px;'>{', '.join(self.available_stocks)}</p>
-                <p>Please select <strong>all 5 stocks</strong> for accurate risk analysis.</p>
-            </div>
-            """
-            return error_html, None, None, None
+            return self.create_error_html(f"Please select exactly these 5 stocks: {', '.join(self.available_stocks)}"), None, None, None
         
         try:
-            # Convert simulations to integer
-            num_simulations = int(num_simulations)
+            simulations = self.run_monte_carlo(selected_stocks, simulation_days, int(num_simulations))
             
-            # Run simulation
-            simulation_results = self.run_monte_carlo(selected_stocks, simulation_days, num_simulations)
+            if simulations is None:
+                return self.create_error_html("Simulation failed"), None, None, None
             
-            if simulation_results is None:
-                error_html = """
-                <div style='text-align: center; padding: 50px; background: #f8d7da; border-radius: 10px;'>
-                    <h3 style='color: #721c24;'>❌ Simulation Failed</h3>
-                    <p>Unable to run simulation. Please try again.</p>
-                </div>
-                """
-                return error_html, None, None, None
-            
-            # Calculate metrics
-            metrics, simulation_array = self.calculate_metrics(simulation_results)
+            metrics = self.calculate_metrics(simulations)
             
             if metrics is None:
-                error_html = """
-                <div style='text-align: center; padding: 50px; background: #f8d7da; border-radius: 10px;'>
-                    <h3 style='color: #721c24;'>❌ Metrics Calculation Failed</h3>
-                    <p>Unable to calculate risk metrics.</p>
-                </div>
-                """
-                return error_html, None, None, None
+                return self.create_error_html("Metrics calculation failed"), None, None, None
+            
+            summary = self.create_summary_html(metrics, selected_stocks, simulation_days, num_simulations)
+            sim_plot = self.create_simulation_plot(simulations)
+            dist_plot = self.create_distribution_plot(simulations, metrics)
+            gauge = self.create_risk_gauge(metrics)
             
-            # Create plots
-            sim_plot = self.create_simulation_plot(simulation_results)
-            dist_plot = self.create_distribution_plot(simulation_results, metrics)
-            risk_gauge = self.create_risk_gauge(metrics)
+            return summary, sim_plot, dist_plot, gauge
+            
+        except Exception as e:
+            return self.create_error_html(f"Analysis error: {str(e)}"), None, None, None
+    
+    def create_error_html(self, message):
+        """Create error message HTML"""
+        return f"""
+        <div style='text-align: center; padding: 40px; background: #f8d7da; border-radius: 10px;'>
+            <h3 style='color: #721c24;'>❌ Error</h3>
+            <p>{message}</p>
+        </div>
+        """
+    
+    def create_summary_html(self, metrics, stocks, days, sims):
+        """Create summary HTML"""
+        risk_level = "LOW" if metrics['prob_10_loss'] < 0.1 else "MEDIUM" if metrics['prob_10_loss'] < 0.2 else "HIGH"
+        risk_color = "#28a745" if risk_level == "LOW" else "#ffc107" if risk_level == "MEDIUM" else "#dc3545"
+        
+        return f"""
+        <div style="padding: 25px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; color: white;">
+            <h2 style="text-align: center;">📊 Risk Analysis Report</h2>
             
-            # Create success summary
-            risk_level = "LOW" if metrics['prob_10_loss'] < 0.15 else "MEDIUM" if metrics['prob_10_loss'] < 0.3 else "HIGH"
-            risk_color = "#28a745" if risk_level == "LOW" else "#ffc107" if risk_level == "MEDIUM" else "#dc3545"
+            <div style="background: rgba(255,255,255,0.1); padding: 20px; border-radius: 10px; margin: 15px 0;">
+                <h3>Portfolio: {', '.join(stocks)}</h3>
+                <p>Weights: 20% each | Period: {days} days | Simulations: {sims}</p>
+            </div>
             
-            summary_html = f"""
-            <div style="font-family: Arial, sans-serif; padding: 25px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; color: white;">
-                <h2 style="text-align: center; margin-bottom: 30px;">📊 Portfolio Risk Analysis Report</h2>
+            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px;">
+                <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
+                    <h4>Expected Value</h4>
+                    <p style="font-size: 24px; font-weight: bold;">${metrics['expected_value']:.2f}</p>
+                </div>
                 
-                <div style="background: rgba(255,255,255,0.1); padding: 20px; border-radius: 10px; margin-bottom: 20px;">
-                    <h3 style="margin-top: 0;">🎯 Trained Portfolio Analysis</h3>
-                    <p style="font-size: 18px; font-weight: bold;">{', '.join(selected_stocks)}</p>
-                    <p>Equal weights (20% each) • {simulation_days} days • {num_simulations} simulations</p>
+                <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
+                    <h4>Risk Level</h4>
+                    <p style="font-size: 24px; font-weight: bold; color: {risk_color};">{risk_level}</p>
                 </div>
                 
-                <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px;">
-                    <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
-                        <h4 style="margin: 0;">Expected Value</h4>
-                        <p style="font-size: 24px; font-weight: bold; margin: 5px 0;">${metrics['expected_value']:.2f}</p>
-                    </div>
-                    
-                    <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
-                        <h4 style="margin: 0;">Risk Level</h4>
-                        <p style="font-size: 24px; font-weight: bold; margin: 5px 0; color: {risk_color};">{risk_level}</p>
-                    </div>
-                    
-                    <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
-                        <h4 style="margin: 0;">10% Loss Probability</h4>
-                        <p style="font-size: 24px; font-weight: bold; margin: 5px 0;">{metrics['prob_10_loss']*100:.1f}%</p>
-                    </div>
-                    
-                    <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
-                        <h4 style="margin: 0;">Worst Case (5%)</h4>
-                        <p style="font-size: 24px; font-weight: bold; margin: 5px 0;">${metrics['var_95']:.2f}</p>
-                    </div>
+                <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
+                    <h4>10% Loss Probability</h4>
+                    <p style="font-size: 24px; font-weight: bold;">{metrics['prob_10_loss']*100:.1f}%</p>
                 </div>
                 
-                <div style="margin-top: 20px; background: rgba(255,255,255,0.1); padding: 15px; border-radius: 8px;">
-                    <h4>📈 Additional Metrics</h4>
-                    <p>20% Loss Probability: <strong>{metrics['prob_20_loss']*100:.1f}%</strong> | 
-                    30% Loss Probability: <strong>{metrics['prob_30_loss']*100:.1f}%</strong> | 
-                    Best Case (95%): <strong>${metrics['best_case']:.2f}</strong></p>
+                <div style="background: rgba(255,255,255,0.2); padding: 15px; border-radius: 8px;">
+                    <h4>Worst Case (5%)</h4>
+                    <p style="font-size: 24px; font-weight: bold;">${metrics['var_95']:.2f}</p>
                 </div>
             </div>
-            """
-            
-            print("✅ Analysis completed successfully!")
-            return summary_html, sim_plot, dist_plot, risk_gauge
-            
-        except Exception as e:
-            error_html = f"""
-            <div style='text-align: center; padding: 50px; background: #f8d7da; border-radius: 10px;'>
-                <h3 style='color: #721c24;'>❌ Analysis Error</h3>
-                <p>Error: {str(e)}</p>
-                <p>Please try again.</p>
-            </div>
-            """
-            print(f"❌ Analysis error: {str(e)}")
-            return error_html, None, None, None
+        </div>
+        """
 
-# Initialize app
+# Create and launch app
 app = GradioRiskApp()
 
-# Create Gradio interface
 with gr.Blocks(theme=gr.themes.Soft(), title="QuantRisk Pro") as demo:
-    gr.Markdown(
-        """
-        # 📊 QuantRisk Pro - Portfolio Risk Analyzer  
-        **AI-Powered Monte Carlo Simulations for Portfolio Risk Assessment**  
-        
-        *Model trained on: AAPL, MSFT, GOOGL, AMZN, TSLA (5 years historical data)*
-        """
-    )
+    gr.Markdown("# 📊 QuantRisk Pro - Portfolio Risk Analyzer")
     
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### 🔧 Portfolio Configuration")
-            
-            gr.Markdown("""
-            **🎯 Trained Stock Portfolio**
-            *This model was specifically trained on these 5 stocks*
-            """)
-            
-            stock_checkboxes = gr.CheckboxGroup(
+            gr.Markdown("### 🔧 Configuration")
+            stocks = gr.CheckboxGroup(
                 choices=app.available_stocks,
-                value=app.available_stocks,  # Auto-select all 5 stocks
-                label="**Select Stocks (Choose ALL 5)**",
-                info="Model works only with these specific stocks"
+                value=app.available_stocks,
+                label="Select Stocks (All 5 Required)"
             )
-            
-            simulation_days = gr.Slider(
-                minimum=30,
-                maximum=500,
-                value=252,
-                step=30,
-                label="**Time Horizon (Days)**",
-                info="Simulation period in trading days (252 = 1 year)"
-            )
-            
-            num_simulations = gr.Dropdown(
-                choices=[1000, 2500, 5000, 10000],
-                value=5000,
-                label="**Number of Simulations**",
-                info="More simulations = more accuracy but slower"
-            )
-            
-            analyze_btn = gr.Button("🚀 Run Risk Analysis", variant="primary", size="lg")
-            
-            gr.Markdown("---")
-            gr.Markdown("""
-            **💡 Important Notes:**
-            - ✅ Model trained on 5 years of AAPL, MSFT, GOOGL, AMZN, TSLA data
-            - ✅ Uses actual historical volatility and correlations
-            - ✅ All 5 stocks must be selected for accurate results
-            - ✅ Equal weights (20% each) applied automatically
-            """)
+            days = gr.Slider(30, 500, 252, label="Time Horizon (Days)")
+            sims = gr.Dropdown([1000, 2500, 5000, 10000], value=5000, label="Simulations")
+            btn = gr.Button("🚀 Analyze", variant="primary")
         
         with gr.Column(scale=2):
-            gr.Markdown("### 📈 Analysis Results")
-            
-            summary_html = gr.HTML(
-                value=f"""
-                <div style='text-align: center; padding: 50px; background: #f8f9fa; border-radius: 10px;'>
-                    <h3 style='color: #6c757d;'>🚀 Ready to Analyze!</h3>
-                    <p>Model trained on: <strong>{', '.join(app.available_stocks)}</strong></p>
-                    <p>All 5 stocks are pre-selected. Click 'Run Risk Analysis' to see your risk report.</p>
-                </div>
-                """
-            )
-            
+            summary = gr.HTML()
             with gr.Row():
-                risk_gauge = gr.Plot(label="**Risk Probability Gauge**")
-                simulation_plot = gr.Plot(label="**Monte Carlo Simulation**")
-            
-            distribution_plot = gr.Plot(label="**Portfolio Value Distribution**")
-    
-    # Footer
-    gr.Markdown("---")
-    gr.Markdown(
-        """
-        <div style="text-align: center; color: #666;">
-            <p>Built with ❤️ using Gradio | QuantRisk Pro v2.0 | Trained on 5 years of historical data</p>
-        </div>
-        """
-    )
+                gauge = gr.Plot()
+                sim_plot = gr.Plot()
+            dist_plot = gr.Plot()
     
-    # Set up event handling
-    analyze_btn.click(
+    btn.click(
         fn=app.analyze_portfolio,
-        inputs=[stock_checkboxes, simulation_days, num_simulations],
-        outputs=[summary_html, simulation_plot, distribution_plot, risk_gauge]
+        inputs=[stocks, days, sims],
+        outputs=[summary, sim_plot, dist_plot, gauge]
     )
 
-# Launch for Hugging Face
 if __name__ == "__main__":
     demo.launch()