Update app.py

app.py

@@ -1,176 +1,89 @@
 import gradio as gr
 import yfinance as yf
-import requests
 import numpy as np
 import pandas as pd
-import matplotlib.pyplot as plt
-from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
-import time
+from scipy.optimize import minimize
 
-# Polymarket GraphQL API endpoint
-POLYMARKET_API = "https://api.polymarket.com/graphql"
+# Define stock tickers (25 from S&P 500)
+TICKERS = [
+    'AAPL', 'MSFT', 'NVDA', 'AVGO', 'ADBE',
+    'AMZN', 'TSLA', 'HD',
+    'PG', 'COST',
+    'UNH', 'JNJ', 'LLY',
+    'JPM', 'GS', 'V',
+    'CAT', 'UNP', 'GE',
+    'XOM', 'NEE',
+    'D',
+    'GOOGL', 'META', 'CMCSA',
+    'PLD'
+]
 
-# Function to fetch Polymarket data
-def fetch_polymarket_data(search_term="S&P"):
+def optimize_portfolio(years, target_return):
     try:
-        query = """
-        query {
-          markets(first: 5, searchTerm: "%s") {
-            edges {
-              node {
-                id
-                question
-                outcomes {
-                  name
-                  price
-                }
-              }
-            }
-          }
-        }
-        """ % search_term
-        response = requests.post(POLYMARKET_API, json={"query": query}, timeout=10)
-        if response.status_code != 200:
-            return None
-        data = response.json()
-        markets = data["data"]["markets"]["edges"]
-        if not markets:
-            return None
-        
-        # Parse the first relevant market
-        for market in markets:
-            node = market["node"]
-            outcomes = node["outcomes"]
-            if len(outcomes) >= 2:
-                return {
-                    "question": node["question"],
-                    "outcomes": {outcome["name"]: float(outcome["price"]) for outcome in outcomes}
-                }
-        return None
-    except Exception as e:
-        return None
-
-# Function to fetch Yahoo Finance data with retry
-def fetch_yahoo_data(ticker, retries=3, delay=2):
-    for attempt in range(retries):
-        try:
-            stock = yf.download(ticker, period="1y", auto_adjust=False, progress=False)
-            if stock.empty or len(stock) < 2:
-                return None, None, None, f"No data returned for ticker '{ticker}'. It may be invalid or lack sufficient history."
-            daily_returns = stock["Close"].pct_change().dropna()
-            if daily_returns.empty:
-                return None, None, None, f"No valid returns calculated for ticker '{ticker}'. Insufficient price data."
-            mu = daily_returns.mean() * 252  # Annualized drift
-            sigma = daily_returns.std() * np.sqrt(252)  # Annualized volatility
-            last_price = stock["Close"][-1]  # Use most recent unadjusted Close
-            return mu, sigma, last_price, None
-        except Exception as e:
-            error_msg = f"Attempt {attempt + 1}/{retries} failed for ticker '{ticker}': {str(e)}"
-            if attempt < retries - 1:
-                time.sleep(delay)  # Wait before retrying
-            else:
-                return None, None, None, error_msg
-    return None, None, None, f"Failed to fetch data for '{ticker}' after {retries} attempts."
-
-# Monte Carlo Simulation with GBM
-def monte_carlo_simulation(S0, mu, sigma, T, N, sims, risk_factor, pm_data):
-    dt = 1 / 252  # Daily time step
-    steps = int(T * 252)
-    sim_paths = np.zeros((sims, steps + 1))
-    sim_paths[:, 0] = S0
-
-    # Adjust drift based on Polymarket probabilities
-    if pm_data and "outcomes" in pm_data:
-        outcomes = pm_data["outcomes"]
-        bullish_prob = outcomes.get("Yes", 0.5) if "Yes" in outcomes else 0.5
-        bearish_prob = 1 - bullish_prob
-        mu_bull = mu * 1.2 * risk_factor
-        mu_bear = mu * -0.5 * risk_factor
-        mu_adjusted = bullish_prob * mu_bull + bearish_prob * mu_bear
-    else:
-        mu_adjusted = mu * risk_factor
-
-    for t in range(1, steps + 1):
-        Z = np.random.standard_normal(sims)
-        sim_paths[:, t] = sim_paths[:, t-1] * np.exp(
-            (mu_adjusted - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z
+        data = yf.download(TICKERS, period=f"{years}y", interval="1mo")['Adj Close']
+        returns = data.pct_change().dropna()
+        mean_returns = returns.mean() * 12
+        cov_matrix = returns.cov() * 12
+
+        num_assets = len(TICKERS)
+        init_weights = np.ones(num_assets) / num_assets
+
+        def portfolio_volatility(weights):
+            return np.sqrt(weights @ cov_matrix @ weights)
+
+        constraints = [
+            {"type": "eq", "fun": lambda w: np.sum(w) - 1},
+            {"type": "eq", "fun": lambda w: w @ mean_returns - target_return}
+        ]
+
+        bounds = tuple((0, 1) for _ in range(num_assets))
+
+        result = minimize(
+            portfolio_volatility,
+            init_weights,
+            method="SLSQP",
+            bounds=bounds,
+            constraints=constraints
         )
-    
-    return sim_paths
-
-# Main simulation function
-def run_simulation(investment, ticker, horizon, num_sims, risk_factor):
-    # Validate inputs
-    if not ticker or investment <= 0 or horizon <= 0 or num_sims <= 0:
-        return None, "Please provide valid inputs: positive investment, horizon, and simulations, and a ticker."
-
-    # Fetch data
-    mu, sigma, S0, error_msg = fetch_yahoo_data(ticker)
-    if mu is None:
-        return None, error_msg
-    
-    pm_data = fetch_polymarket_data("S&P")
-    
-    # Run Monte Carlo simulation
-    sim_paths = monte_carlo_simulation(S0, mu, sigma, horizon, num_sims, num_sims, risk_factor, pm_data)
-    final_values = sim_paths[:, -1] * (investment / S0)  # Scale to investment amount
-    
-    # Create histogram
-    fig, ax = plt.subplots(figsize=(8, 6))
-    ax.hist(final_values, bins=50, color="skyblue", edgecolor="black")
-    ax.set_title(f"Distribution of Final Investment Value ({ticker})")
-    ax.set_xlabel("Final Value ($)")
-    ax.set_ylabel("Frequency")
-    plt.tight_layout()
-    
-    # Calculate stats
-    mean_val = np.mean(final_values)
-    min_val = np.min(final_values)
-    max_val = np.max(final_values)
-    std_val = np.std(final_values)
-    
-    # Prepare summary text
-    summary = f"Market Data (Yahoo Finance):\n"
-    summary += f"- Drift (μ): {mu:.4f} (based on unadjusted Close)\n"
-    summary += f"- Volatility (σ): {sigma:.4f}\n"
-    summary += f"- Last Close Price: ${S0:.2f}\n\n"
-    if pm_data:
-        summary += f"Polymarket Data:\n- Question: {pm_data['question']}\n"
-        for outcome, prob in pm_data["outcomes"].items():
-            summary += f"- {outcome}: {prob*100:.1f}%\n"
-    else:
-        summary += "Polymarket Data: No relevant market found or API unavailable.\n"
-    summary += f"\nSimulation Results ({num_sims} runs):\n"
-    summary += f"- Mean Final Value: ${mean_val:.2f}\n"
-    summary += f"- Min Final Value: ${min_val:.2f}\n"
-    summary += f"- Max Final Value: ${max_val:.2f}\n"
-    summary += f"- Std Dev: ${std_val:.2f}"
-    
-    return fig, summary
-
-# Gradio UI
-with gr.Blocks(title="Investment Simulation Platform") as demo:
-    gr.Markdown("# Investment Decision Simulation Platform")
-    gr.Markdown("Simulate investment outcomes using Yahoo Finance data (unadjusted) and Polymarket probabilities.")
-    
+
+        if not result.success:
+            return "Optimization failed. Try adjusting inputs.", None, None, None
+
+        weights = result.x
+        port_return = weights @ mean_returns
+        port_vol = np.sqrt(weights @ cov_matrix @ weights)
+        risk_free_rate = 0.045
+        sharpe_ratio = (port_return - risk_free_rate) / port_vol
+
+        df = pd.DataFrame({
+            "Ticker": TICKERS,
+            "Weight (%)": np.round(weights * 100, 2)
+        }).sort_values("Weight (%)", ascending=False).reset_index(drop=True)
+
+        return df, f"{port_return*100:.2f}%", f"{port_vol*100:.2f}%", f"{sharpe_ratio:.2f}"
+
+    except Exception as e:
+        return f"Error: {str(e)}", None, None, None
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 📈 Modern Portfolio Optimizer (MPT)")
+    gr.Markdown("Select number of years of historical data and your target annual return. This app computes the **minimum risk portfolio** of 25 S&P 500 stocks.")
+
     with gr.Row():
-        with gr.Column():
-            investment = gr.Number(label="Investment Amount ($)", value=10000)
-            ticker = gr.Textbox(label="Ticker Symbol (e.g., AAPL, ^GSPC)", value="AAPL")
-            horizon = gr.Number(label="Investment Horizon (Years)", value=1)
-            num_sims = gr.Number(label="Number of Simulations", value=1000)
-            risk_factor = gr.Slider(0.5, 2.0, value=1.0, label="Risk Factor")
-            submit_btn = gr.Button("Run Simulation")
-        
-        with gr.Column():
-            plot_output = gr.Plot(label="Final Value Distribution")
-            text_output = gr.Textbox(label="Simulation Summary", lines=12)
-    
-    submit_btn.click(
-        fn=run_simulation,
-        inputs=[investment, ticker, horizon, num_sims, risk_factor],
-        outputs=[plot_output, text_output]
+        years_slider = gr.Slider(1, 10, value=5, step=1, label="Years of Historical Data")
+        return_slider = gr.Slider(1.0, 15.0, value=5.0, step=0.1, label="Target Annual Return (%)")
+
+    run_button = gr.Button("Optimize Portfolio")
+
+    output_table = gr.Dataframe(headers=["Ticker", "Weight (%)"], label="Optimal Allocation")
+    ret_text = gr.Text(label="Expected Return")
+    vol_text = gr.Text(label="Expected Volatility")
+    sharpe_text = gr.Text(label="Sharpe Ratio")
+
+    run_button.click(
+        fn=lambda years, target: optimize_portfolio(years, target / 100),
+        inputs=[years_slider, return_slider],
+        outputs=[output_table, ret_text, vol_text, sharpe_text]
     )
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()