Update app.py

app.py

@@ -3,108 +3,124 @@ import pandas as pd
 import numpy as np
 import plotly.graph_objects as go
 import plotly.express as px
-from plotly.subplots import make_subplots
 import yfinance as yf
 from datetime import datetime, timedelta
 import pickle
-import json
 import warnings
 warnings.filterwarnings('ignore')
 
-# Load trained model
+# Load trained model - USING YOUR SPECIFIC STOCKS
 def load_model():
     try:
         with open('portfolio_risk_model.pkl', 'rb') as f:
             model = pickle.load(f)
+        print("✅ Model loaded successfully!")
+        print(f"📊 Model trained on: {model['tickers']}")
         return model
     except Exception as e:
-        print(f"Model loading error: {str(e)}")
+        print(f"❌ Model loading error: {str(e)}")
         return None
 
 class GradioRiskApp:
     def __init__(self):
         self.model = load_model()
-        self.available_stocks = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'TSLA', 
-                                'META', 'NVDA', 'NFLX', 'JPM', 'JNJ',
-                                'V', 'PG', 'DIS', 'BAC', 'XOM']
+        
+        # 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}")
     
-    def get_current_data(self, symbols, period='1y'):
-        """Get current stock data"""
+    def run_monte_carlo(self, selected_stocks, days=252, simulations=5000):
+        """Run Monte Carlo simulation using the trained model"""
         try:
-            data = yf.download(symbols, period=period)['Adj Close']
-            return data
-        except Exception as e:
-            print(f"Data fetch error: {str(e)}")
-            return None
-    
-    def run_monte_carlo(self, weights, days=252, simulations=5000):
-        """Run Monte Carlo simulation with given weights"""
-        if self.model is None:
-            return None
+            if self.model is None:
+                return "❌ Model not loaded properly", None, None, None
             
-        mean_returns = np.array(self.model['mean_returns'])
-        cov_matrix = np.array(self.model['covariance_matrix'])
-        
-        # Generate simulation
-        np.random.seed(42)
-        try:
-            L = np.linalg.cholesky(cov_matrix)
-        except:
-            eigvals, eigvecs = np.linalg.eigh(cov_matrix)
-            L = eigvecs @ np.diag(np.sqrt(eigvals))
-        
-        simulation_results = []
-        for _ in range(simulations):
-            random_numbers = np.random.normal(0, 1, size=(days, len(mean_returns)))
-            correlated_randoms = random_numbers @ L.T
-            daily_returns = correlated_randoms + mean_returns
+            # 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
+            
+            n_stocks = len(selected_stocks)
+            print(f"🎯 Running MC simulation for {selected_stocks}...")
             
-            portfolio_value = 100
-            portfolio_path = [portfolio_value]
+            # Use the trained model parameters
+            mean_returns = np.array(self.model['mean_returns'])
+            cov_matrix = np.array(self.model['covariance_matrix'])
             
-            for day in range(days):
-                daily_portfolio_return = np.dot(daily_returns[day], weights)
-                portfolio_value *= (1 + daily_portfolio_return)
-                portfolio_path.append(portfolio_value)
+            # 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)))
             
-            simulation_results.append(portfolio_path)
-        
-        return np.array(simulation_results)
+            simulation_results = []
+            equal_weights = np.array([0.2, 0.2, 0.2, 0.2, 0.2])  # Equal weights for 5 stocks
+            
+            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
+                
+                portfolio_value = 100
+                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)
+                    portfolio_path.append(portfolio_value)
+                
+                simulation_results.append(portfolio_path)
+            
+            print(f"✅ Simulation completed: {len(simulation_results)} paths")
+            return simulation_results
+            
+        except Exception as e:
+            print(f"❌ Simulation error: {str(e)}")
+            return None
     
     def calculate_metrics(self, simulation_results):
         """Calculate risk metrics from simulation"""
-        final_values = simulation_results[:, -1]
+        if simulation_results is None:
+            return None
+            
+        simulation_array = np.array(simulation_results)
+        final_values = simulation_array[:, -1]
         
         metrics = {
             'expected_value': np.mean(final_values),
-            'median_value': np.median(final_values),
-            'std_value': np.std(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)
+            'worst_case': np.percentile(final_values, 5),
+            'median_value': np.median(final_values)
         }
         
-        return metrics
+        return metrics, simulation_array
     
     def create_simulation_plot(self, simulation_results):
         """Create Monte Carlo simulation plot"""
+        if simulation_results is None:
+            return None
+            
         fig = go.Figure()
         
-        # Sample paths
-        for i in range(min(50, len(simulation_results))):
+        # Show only 30 paths for clarity
+        for i in range(min(30, len(simulation_results))):
             fig.add_trace(go.Scatter(
                 y=simulation_results[i],
                 mode='lines',
-                line=dict(width=1, color='blue'),
-                opacity=0.1,
+                line=dict(width=1, color='lightblue'),
+                opacity=0.3,
                 showlegend=False
             ))
         
         # Mean path
-        mean_path = simulation_results.mean(axis=0)
+        mean_path = np.mean(simulation_results, axis=0)
         fig.add_trace(go.Scatter(
             y=mean_path,
             mode='lines',
@@ -113,145 +129,193 @@ class GradioRiskApp:
         ))
         
         fig.update_layout(
-            title="Monte Carlo Simulation Paths",
+            title="📈 Monte Carlo Simulation Paths",
             xaxis_title="Trading Days",
             yaxis_title="Portfolio Value ($)",
-            height=400
+            height=400,
+            showlegend=True
         )
         
         return fig
     
     def create_distribution_plot(self, simulation_results, metrics):
         """Create final value distribution plot"""
-        final_values = simulation_results[:, -1]
+        if simulation_results is None:
+            return None
+            
+        final_values = np.array(simulation_results)[:, -1]
         
         fig = px.histogram(
             x=final_values,
             nbins=50,
-            title="Distribution of Final Portfolio Values",
+            title="📊 Distribution of Final Portfolio Values",
             color_discrete_sequence=['#FF6B6B']
         )
         
-        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}")
+        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.update_layout(height=400, showlegend=False)
-        
         return fig
     
     def create_risk_gauge(self, metrics):
         """Create risk probability gauge"""
+        if metrics is None:
+            return None
+            
         risk_prob = metrics['prob_10_loss'] * 100
         
         fig = go.Figure(go.Indicator(
-            mode = "gauge+number+delta",
+            mode = "gauge+number",
             value = risk_prob,
             domain = {'x': [0, 1], 'y': [0, 1]},
-            title = {'text': "Probability of >10% Loss"},
+            title = {'text': "🔴 Probability of >10% Loss"},
             gauge = {
                 'axis': {'range': [None, 50]},
-                'bar': {'color': "darkblue"},
+                'bar': {'color': "darkred"},
                 'steps': [
-                    {'range': [0, 10], 'color': "lightgreen"},
-                    {'range': [10, 25], 'color': "yellow"},
-                    {'range': [25, 50], 'color': "red"}],
+                    {'range': [0, 15], 'color': "lightgreen"},
+                    {'range': [15, 30], 'color': "yellow"},
+                    {'range': [30, 50], 'color': "red"}],
                 'threshold': {
-                    'line': {'color': "red", 'width': 4},
+                    'line': {'color': "black", 'width': 4},
                     'thickness': 0.75,
-                    'value': 30}}
+                    'value': 25}}
         ))
         fig.update_layout(height=300)
-        
         return fig
     
     def analyze_portfolio(self, selected_stocks, simulation_days, num_simulations):
-        """Main analysis function for Gradio"""
+        """Main analysis function"""
+        print(f"🔍 Analyzing portfolio: {selected_stocks}")
+        
         if not selected_stocks:
-            return "Please select at least one stock", None, None, None, None
+            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
+        
+        # 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
         
         try:
-            # Equal weights for selected stocks
-            n_stocks = len(selected_stocks)
-            weights = [1/n_stocks] * n_stocks
+            # Convert simulations to integer
+            num_simulations = int(num_simulations)
             
             # Run simulation
-            simulation_results = self.run_monte_carlo(weights, simulation_days, num_simulations)
+            simulation_results = self.run_monte_carlo(selected_stocks, simulation_days, num_simulations)
             
             if simulation_results is None:
-                return "Error in simulation", None, None, None, 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 = self.calculate_metrics(simulation_results)
+            metrics, simulation_array = self.calculate_metrics(simulation_results)
+            
+            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
             
             # 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)
             
-            # Create metrics summary
+            # 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"
+            
             summary_html = f"""
-            <div style="font-family: Arial, sans-serif; padding: 20px; background: #f5f5f5; border-radius: 10px;">
-                <h2 style="color: #333; text-align: center;">📊 Portfolio Risk Analysis Report</h2>
+            <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; margin-top: 20px;">
-                    <div style="background: white; padding: 15px; border-radius: 8px; border-left: 4px solid #4CAF50;">
-                        <h3 style="margin: 0; color: #666;">Expected Value</h3>
-                        <p style="font-size: 24px; font-weight: bold; color: #333; margin: 5px 0;">${metrics['expected_value']:.2f}</p>
+                <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>
+                
+                <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: white; padding: 15px; border-radius: 8px; border-left: 4px solid #FF9800;">
-                        <h3 style="margin: 0; color: #666;">Value at Risk (95%)</h3>
-                        <p style="font-size: 24px; font-weight: bold; color: #333; margin: 5px 0;">${metrics['var_95']:.2f}</p>
+                    <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: white; padding: 15px; border-radius: 8px; border-left: 4px solid #F44336;">
-                        <h3 style="margin: 0; color: #666;">10% Loss Probability</h3>
-                        <p style="font-size: 24px; font-weight: bold; color: #333; margin: 5px 0;">{metrics['prob_10_loss']*100:.1f}%</p>
+                    <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: white; padding: 15px; border-radius: 8px; border-left: 4px solid #2196F3;">
-                        <h3 style="margin: 0; color: #666;">Best Case (95%)</h3>
-                        <p style="font-size: 24px; font-weight: bold; color: #333; margin: 5px 0;">${metrics['best_case']:.2f}</p>
+                    <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>
                 
-                <div style="margin-top: 20px;">
-                    <h3 style="color: #333;">Portfolio Composition:</h3>
-                    <p style="color: #666;">{', '.join(selected_stocks)}</p>
-                    <p style="color: #666;">Equal weights: {', '.join([f'{w*100:.1f}%' for w in weights])}</p>
+                <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>
             </div>
             """
             
-            return summary_html, sim_plot, dist_plot, risk_gauge, None
+            print("✅ Analysis completed successfully!")
+            return summary_html, sim_plot, dist_plot, risk_gauge
             
         except Exception as e:
-            return f"Error in analysis: {str(e)}", None, None, None, None
+            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
 
-# Initialize the app
+# Initialize app
 app = GradioRiskApp()
 
-# Custom CSS for better styling
-custom_css = """
-.gradio-container {
-    font-family: 'Arial', sans-serif;
-}
-.container {
-    max-width: 1200px;
-    margin: 0 auto;
-}
-"""
-
 # Create Gradio interface
-with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
+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**
+        # 📊 QuantRisk Pro - Portfolio Risk Analyzer  
+        **AI-Powered Monte Carlo Simulations for Portfolio Risk Assessment**  
         
-        *Analyze your stock portfolio risk using advanced probabilistic models*
+        *Model trained on: AAPL, MSFT, GOOGL, AMZN, TSLA (5 years historical data)*
         """
     )
     
@@ -259,11 +323,16 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
         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(
                 choices=app.available_stocks,
-                value=['AAPL', 'MSFT', 'GOOGL'],
-                label="Select Stocks for Portfolio",
-                info="Choose up to 10 stocks"
+                value=app.available_stocks,  # Auto-select all 5 stocks
+                label="**Select Stocks (Choose ALL 5)**",
+                info="Model works only with these specific stocks"
             )
             
             simulation_days = gr.Slider(
@@ -271,52 +340,64 @@ with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
                 maximum=500,
                 value=252,
                 step=30,
-                label="Time Horizon (Days)",
-                info="Simulation period in trading days"
+                label="**Time Horizon (Days)**",
+                info="Simulation period in trading days (252 = 1 year)"
             )
             
-            num_simulations = gr.Radio(
+            num_simulations = gr.Dropdown(
                 choices=[1000, 2500, 5000, 10000],
                 value=5000,
-                label="Number of Simulations",
-                info="More simulations = more accuracy"
+                label="**Number of Simulations**",
+                info="More simulations = more accuracy but slower"
             )
             
-            analyze_btn = gr.Button("🚀 Run Risk Analysis", variant="primary")
+            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
+            """)
         
         with gr.Column(scale=2):
             gr.Markdown("### 📈 Analysis Results")
             
             summary_html = gr.HTML(
-                label="Risk Summary",
-                value="<div style='text-align: center; color: #666; padding: 50px;'>Configure your portfolio and click 'Run Risk Analysis' to see results</div>"
+                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>
+                """
             )
             
             with gr.Row():
-                risk_gauge = gr.Plot(label="Risk Probability Gauge")
-                simulation_plot = gr.Plot(label="Monte Carlo Simulation")
+                risk_gauge = gr.Plot(label="**Risk Probability Gauge**")
+                simulation_plot = gr.Plot(label="**Monte Carlo Simulation**")
             
-            with gr.Row():
-                distribution_plot = gr.Plot(label="Value Distribution")
+            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 v1.0</p>
-            <p>Uses Monte Carlo simulations and historical data for risk assessment</p>
+            <p>Built with ❤️ using Gradio | QuantRisk Pro v2.0 | Trained on 5 years of historical data</p>
         </div>
         """
     )
     
-    # Set up the analysis function
+    # Set up event handling
     analyze_btn.click(
         fn=app.analyze_portfolio,
         inputs=[stock_checkboxes, simulation_days, num_simulations],
         outputs=[summary_html, simulation_plot, distribution_plot, risk_gauge]
     )
 
-# Launch the app
+# Launch for Hugging Face
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch()