Update app.py

app.py

@@ -1,12 +1,7 @@
 # app.py
-import os, io, math, time, warnings
+import os, io, math, time, warnings, json
 warnings.filterwarnings("ignore")
 
-# --- make matplotlib headless & writable ---
-import matplotlib
-matplotlib.use("Agg")
-os.environ.setdefault("MPLCONFIGDIR", "/home/user/.config/matplotlib")
-
 from typing import List, Tuple, Dict, Optional
 
 import numpy as np
@@ -25,12 +20,15 @@ MAX_TICKERS = 30
 DEFAULT_LOOKBACK_YEARS = 10
 MARKET_TICKER = "VOO"
 
-SYNTH_ROWS = 1000  # size of generated dataset for suggestions
+SYNTH_ROWS = 1000  # dataset size for suggestions
+EMBED_MODEL_NAME = "FinLang/finance-embeddings-investopedia"
+EMBED_ALPHA = 0.6   # score = alpha*exposure_sim + (1-alpha)*embedding_sim
+MMR_LAMBDA = 0.7    # diversity tradeoff for MMR (higher = prefer quality)
 
-# Globals that update with horizon changes
+# Globals updated by horizon control
 HORIZON_YEARS = 10
 RF_CODE = "DGS10"
-RF_ANN = 0.0375  # updated at launch
+RF_ANN = 0.0375      # refreshed at launch
 
 # ---------------- helpers ----------------
 def fred_series_for_horizon(years: float) -> str:
@@ -55,8 +53,8 @@ def fetch_fred_yield_annual(code: str) -> float:
         return 0.03
 
 def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
-    tickers = list(dict.fromkeys([t.upper().strip() for t in tickers]))
-    start = (pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=years, days=7)).date()
+    tickers = list(dict.fromkeys([t.upper().strip() for t in tickers if t]))
+    start = (pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=int(years), days=7)).date()
     end = pd.Timestamp.today(tz="UTC").date()
 
     df = yf.download(
@@ -71,7 +69,7 @@ def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
         threads=False,
     )
 
-    # Normalize to wide frame of prices (one column per ticker)
+    # Normalize to wide (Close) frame
     if isinstance(df, pd.Series):
         df = df.to_frame()
     if isinstance(df.columns, pd.MultiIndex):
@@ -118,7 +116,7 @@ def validate_tickers(symbols: List[str], years: int) -> List[str]:
     px = fetch_prices_monthly(base + [MARKET_TICKER], years)
     ok = [s for s in base if s in px.columns]
     if MARKET_TICKER not in px.columns:
-        return []
+        return []  # we need a market proxy to align CAPM
     return ok
 
 # -------------- aligned moments --------------
@@ -154,7 +152,6 @@ def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
         ex_s = R[s] - rf_m
         cov_sm = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1])
         betas[s] = cov_sm / var_m
-
     betas[MARKET_TICKER] = 1.0
 
     asset_cols = [c for c in R.columns if c != MARKET_TICKER]
@@ -179,55 +176,76 @@ def portfolio_stats(weights: Dict[str, float],
     w_expo = w / gross
     beta_p = float(np.dot([betas.get(t, 0.0) for t in tickers], w_expo))
     mu_capm = capm_er(beta_p, rf_ann, erp_ann)
-    cov = cov_ann.reindex(index=tickers, columns=tickers).fillna(0.0).to_numpy()
-    sigma_hist = float(max(w_expo.T @ cov @ w_expo, 0.0)) ** 0.5
-    return beta_p, mu_capm, sigma_hist  # <-- X uses HIST sigma
+    cov = cov_ann.reindex(index=[t for t in tickers if t != MARKET_TICKER],
+                          columns=[t for t in tickers if t != MARKET_TICKER]).fillna(0.0).to_numpy()
+    # treat market ticker (if any) as index asset with β=1; variance from cov_ann is on asset-only block
+    # when MARKET_TICKER is in weights, its variance contribution is ignored in cov (ok; σ_hist is approximate)
+    sigma_hist = 0.0
+    if cov.size and all(t != MARKET_TICKER for t in tickers):
+        sigma_hist = float(max(w_expo.T @ cov @ w_expo, 0.0)) ** 0.5
+    else:
+        # fallback: use weighted average variance/cov if market present; approximate via available submatrix
+        sub_t = [t for t in tickers if t != MARKET_TICKER]
+        if sub_t:
+            sub_w = np.array([weights[t] for t in sub_t], dtype=float)
+            sub_w = sub_w / max(np.sum(np.abs(sub_w)), 1e-12)
+            sub_cov = cov_ann.reindex(index=sub_t, columns=sub_t).fillna(0.0).to_numpy()
+            sigma_hist = float(max(sub_w.T @ sub_cov @ sub_w, 0.0)) ** 0.5
+        else:
+            sigma_hist = 0.0
+    return beta_p, mu_capm, sigma_hist
 
 def efficient_same_sigma(sigma_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
     if sigma_mkt <= 1e-12:
         return 0.0, 1.0, rf_ann
     a = sigma_target / sigma_mkt
-    return a, 1.0 - a, rf_ann + a * erp_ann
+    return a, 1.0 - a, rf_ann + a * erp_ann  # weights (market, bills), return
 
 def efficient_same_return(mu_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
     if abs(erp_ann) <= 1e-12:
         return 0.0, 1.0, rf_ann
     a = (mu_target - rf_ann) / erp_ann
-    return a, 1.0 - a, abs(a) * sigma_mkt
+    return a, 1.0 - a, abs(a) * sigma_mkt  # weights (market, bills), sigma
 
-# -------------- plotting (CAPM on CML) --------------
+# -------------- plotting --------------
 def _pct(x):
     return np.asarray(x, dtype=float) * 100.0
 
-def plot_cml(
+def plot_cml_hybrid(
     rf_ann, erp_ann, sigma_mkt,
-    sigma_hist, mu_capm,
-    mu_same_sigma, sigma_same_mu,
-    sugg_mu=None, sugg_sigma=None
+    sigma_hist_port, mu_capm_port,
+    mu_eff_same_sigma, sigma_eff_same_return,
+    sugg_mu=None, sugg_sigma_hist=None
 ) -> Image.Image:
-    fig = plt.figure(figsize=(6, 4), dpi=120)
-
-    xmax = max(0.3, sigma_mkt * 2.2, (sigma_hist or 0.0) * 1.6, (sugg_sigma or 0.0) * 1.6)
-    xs = np.linspace(0, xmax, 200)
-    cml = rf_ann + (erp_ann / max(sigma_mkt, 1e-9)) * xs
-
-    plt.plot(_pct(xs), _pct(cml), label="CML via Market", linewidth=1.8)
-    plt.scatter([_pct(0)], [_pct(rf_ann)], label="Risk-free")
-    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label="Market")
-
-    # YOUR point: X = historical sigma, Y = CAPM expected return
-    plt.scatter([_pct(sigma_hist)], [_pct(mu_capm)], label="Your CAPM point", marker="o")
-
-    # Efficient references on CML
-    plt.scatter([_pct(sigma_hist)], [_pct(mu_same_sigma)], label="Efficient: same σ", marker="^")
-    plt.scatter([_pct(sigma_same_mu)], [_pct(mu_capm)], label="Efficient: same E[r]", marker="v")
-
-    if sugg_mu is not None and sugg_sigma is not None:
-        plt.scatter([_pct(sugg_sigma)], [_pct(sugg_mu)], label="Selected Suggestion", marker="X", s=60)
-
-    plt.xlabel("σ (annualized, %)")
-    plt.ylabel("Expected return (annual, %)")
-    plt.legend(loc="best")
+    fig = plt.figure(figsize=(6.5, 4.2), dpi=120)
+
+    xmax = max(0.3,
+               sigma_mkt * 2.2,
+               (sigma_hist_port or 0.0) * 1.6,
+               (sigma_eff_same_return or 0.0) * 1.6,
+               (sugg_sigma_hist or 0.0) * 1.6)
+    xs = np.linspace(0.0, xmax, 240)
+    cml = rf_ann + (erp_ann / max(sigma_mkt, 1e-9)) * xs if sigma_mkt > 1e-12 else np.full_like(xs, rf_ann)
+
+    # CML and fixtures
+    plt.plot(_pct(xs), _pct(cml), label="CML (Market/Bills)", linewidth=1.8)
+    plt.scatter([_pct(0)], [_pct(rf_ann)], label="Risk-free", zorder=3)
+    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label="Market", zorder=3)
+
+    # Your CAPM point (x = historical σ, y = CAPM E[r])
+    plt.scatter([_pct(sigma_hist_port)], [_pct(mu_capm_port)], label="Your CAPM point", marker="o", zorder=4)
+
+    # Efficient points
+    plt.scatter([_pct(sigma_hist_port)], [_pct(mu_eff_same_sigma)], label="Efficient (same σ)", marker="^", zorder=4)
+    plt.scatter([_pct(sigma_eff_same_return)], [_pct(mu_capm_port)], label="Efficient (same E[r])", marker="s", zorder=4)
+
+    # Selected suggestion
+    if (sugg_mu is not None) and (sugg_sigma_hist is not None):
+        plt.scatter([_pct(sugg_sigma_hist)], [_pct(sugg_mu)], label="Selected Suggestion", marker="X", s=70, zorder=5)
+
+    plt.xlabel("σ (historical, annualized, %)")
+    plt.ylabel("CAPM E[r] (annual, %)")
+    plt.legend(loc="best", fontsize=8)
     plt.tight_layout()
 
     buf = io.BytesIO()
@@ -253,24 +271,33 @@ def build_synthetic_dataset(universe: List[str],
     for _ in range(n_rows):
         k = int(rng.integers(low=2, high=min(8, len(universe)) + 1))
         picks = list(rng.choice(universe, size=k, replace=False))
+
+        # long-only for clarity in suggestions
         w = rng.dirichlet(np.ones(k))
+
+        # beta and CAPM E[r]
         beta_p = float(np.dot([betas.get(t, 0.0) for t in picks], w))
         mu_capm = capm_er(beta_p, rf_ann, erp_ann)
-        sub = covA.reindex(index=picks, columns=picks).fillna(0.0).to_numpy()
-        sigma_hist = float(max(w.T @ sub @ w, 0.0)) ** 0.5
-        sigma_capm = abs(beta_p) * sigma_mkt
+
+        # historical sigma from covA (ignore MARKET_TICKER variance entry)
+        sub = [t for t in picks if t != MARKET_TICKER]
+        if sub:
+            sub_w = np.array([w[i] for i, t in enumerate(picks) if t != MARKET_TICKER], dtype=float)
+            sub_cov = covA.reindex(index=sub, columns=sub).fillna(0.0).to_numpy()
+            sigma_hist = float(max(sub_w.T @ sub_cov @ sub_w, 0.0)) ** 0.5
+        else:
+            sigma_hist = 0.0
 
         rows.append({
             "tickers": ",".join(picks),
             "weights": ",".join(f"{x:.6f}" for x in w),
             "beta": beta_p,
             "mu_capm": mu_capm,
-            "sigma_hist": sigma_hist,
-            "sigma_capm": sigma_capm
+            "sigma_hist": sigma_hist
         })
     return pd.DataFrame(rows)
 
-def _band_bounds(sigma_mkt: float, band: str) -> Tuple[float, float]:
+def _band_bounds_sigma_hist(sigma_mkt: float, band: str) -> Tuple[float, float]:
     band = (band or "Medium").strip().lower()
     if band.startswith("low"):
         return 0.0, 0.8 * sigma_mkt
@@ -278,46 +305,150 @@ def _band_bounds(sigma_mkt: float, band: str) -> Tuple[float, float]:
         return 1.2 * sigma_mkt, 3.0 * sigma_mkt
     return 0.8 * sigma_mkt, 1.2 * sigma_mkt
 
-def top3_by_return_in_band(df: pd.DataFrame, band: str, sigma_mkt: float) -> pd.DataFrame:
-    lo, hi = _band_bounds(sigma_mkt, band)
-    pick = df[(df["sigma_capm"] >= lo) & (df["sigma_capm"] <= hi)].copy()
-    if pick.empty:
-        pick = df.copy()
-    pick = pick.sort_values("mu_capm", ascending=False).head(3).reset_index(drop=True)
-    pick.insert(0, "pick", [1, 2, 3][: len(pick)])
-    return pick
-
-# -------------- optional: embeddings rerank --------------
-def rerank_with_embeddings(top3: pd.DataFrame, band: str) -> pd.DataFrame:
+def _summarize_three(df: pd.DataFrame) -> pd.DataFrame:
+    if df.empty:
+        return pd.DataFrame(columns=["pick", "CAPM E[r] %", "σ (hist) %", "tickers"])
+    out = df.copy()
+    out = out.assign(**{
+        "CAPM E[r] %": (out["mu_capm"] * 100.0).round(2),
+        "σ (hist) %": (out["sigma_hist"] * 100.0).round(2),
+        "tickers": out["tickers"]
+    })[["CAPM E[r] %", "σ (hist) %", "tickers"]].reset_index(drop=True)
+    out.insert(0, "pick", [1, 2, 3][: len(out)])
+    return out
+
+# -------------- embeddings & re-ranking --------------
+_EMBED_MODEL = None
+_TICKER_EMBED_CACHE: Dict[str, np.ndarray] = {}
+
+def _load_embed_model():
+    global _EMBED_MODEL
+    if _EMBED_MODEL is not None:
+        return _EMBED_MODEL
     try:
         from sentence_transformers import SentenceTransformer
-        model = SentenceTransformer("FinLang/finance-embeddings-investopedia")
-        prompt = {
-            "low": "low risk conservative portfolio stable diversified market exposure",
-            "medium": "balanced medium risk diversified portfolio",
-            "high": "high risk growth aggressive portfolio higher expected return"
-        }[(band or "medium").lower() if (band or "medium").lower() in {"low","medium","high"} else "medium"]
-
-        cand_texts = []
-        for _, r in top3.iterrows():
-            cand_texts.append(
-                f"portfolio with tickers {r['tickers']} having beta {float(r['beta']):.2f}, "
-                f"expected return {float(r['mu_capm']):.3f}, sigma {float(r['sigma_capm']):.3f}"
-            )
-
-        q = model.encode([prompt])
-        c = model.encode(cand_texts)
-        sims = (q @ c.T) / (np.linalg.norm(q) * np.linalg.norm(c, axis=1, keepdims=False))
-        order = np.argsort(-sims.ravel())
-        return top3.iloc[order].reset_index(drop=True)
+        _EMBED_MODEL = SentenceTransformer(EMBED_MODEL_NAME)
     except Exception:
-        return top3
+        _EMBED_MODEL = None
+    return _EMBED_MODEL
+
+def _embed_texts(texts: List[str]) -> np.ndarray:
+    model = _load_embed_model()
+    if model is None:
+        return np.zeros((len(texts), 384), dtype=float)  # fallback dim
+    return np.array(model.encode(texts), dtype=float)
+
+def _ticker_vec(t: str) -> np.ndarray:
+    t = t.upper().strip()
+    if t in _TICKER_EMBED_CACHE:
+        return _TICKER_EMBED_CACHE[t]
+    v = _embed_texts([f"ticker {t}"])[0]
+    _TICKER_EMBED_CACHE[t] = v
+    return v
+
+def _portfolio_embedding(tickers: List[str], weights: List[float]) -> np.ndarray:
+    if not tickers:
+        return np.zeros(384, dtype=float)
+    w = np.array(weights, dtype=float)
+    s = float(np.sum(np.abs(w)))
+    if s <= 1e-12:
+        w = np.ones(len(tickers), dtype=float) / len(tickers)
+    else:
+        w = w / s
+    vs = np.stack([_ticker_vec(t) for t in tickers], axis=0)
+    v = (w[:, None] * vs).sum(axis=0)
+    n = float(np.linalg.norm(v))
+    return v / (n if n > 1e-12 else 1.0)
+
+def _cos_sim(a: np.ndarray, b: np.ndarray) -> float:
+    na = float(np.linalg.norm(a)); nb = float(np.linalg.norm(b))
+    if na <= 1e-12 or nb <= 1e-12: return 0.0
+    return float(np.dot(a, b) / (na * nb))
+
+def _exposure_similarity(user_map: Dict[str, float], cand_map: Dict[str, float]) -> float:
+    # overlap mass on common tickers (long-only style 0..1)
+    s_user = sum(abs(x) for x in user_map.values())
+    s_cand = sum(abs(x) for x in cand_map.values())
+    if s_user <= 1e-12 or s_cand <= 1e-12:
+        return 0.0
+    u = {k: abs(v) / s_user for k, v in user_map.items()}
+    c = {k: abs(v) / s_cand for k, v in cand_map.items()}
+    common = set(u.keys()) & set(c.keys())
+    return float(sum(min(u[t], c[t]) for t in common))
+
+def rerank_band_with_embeddings(user_df: pd.DataFrame,
+                                band_df: pd.DataFrame,
+                                alpha: float = EMBED_ALPHA,
+                                mmr_lambda: float = MMR_LAMBDA,
+                                top_k: int = 3) -> pd.DataFrame:
+    try:
+        # user portfolio embedding
+        u_t = user_df["ticker"].astype(str).str.upper().tolist()
+        u_w = pd.to_numeric(user_df["amount_usd"], errors="coerce").fillna(0.0).tolist()
+        u_map = {t: float(w) for t, w in zip(u_t, u_w)}
+        u_embed = _portfolio_embedding(u_t, u_w)
+
+        # candidate scores
+        cand_rows = []
+        cand_embeds = []
+        for _, r in band_df.iterrows():
+            ts = [t.strip().upper() for t in str(r["tickers"]).split(",")]
+            ws = [float(x) for x in str(r["weights"]).split(",")]
+            # normalize candidate weights
+            s = sum(max(0.0, w) for w in ws) or 1.0
+            ws = [max(0.0, w) / s for w in ws]
+            c_map = {t: w for t, w in zip(ts, ws)}
+
+            c_embed = _portfolio_embedding(ts, ws)
+            cand_embeds.append(c_embed)
+
+            expo_sim = _exposure_similarity(u_map, c_map)
+            emb_sim = _cos_sim(u_embed, c_embed)
+            score = alpha * expo_sim + (1.0 - alpha) * emb_sim
+
+            cand_rows.append((score, r))
+
+        if not cand_rows:
+            return band_df.head(top_k).reset_index(drop=True)
+
+        # MMR selection
+        cand_embeds = np.stack(cand_embeds, axis=0)
+        order = np.argsort([-s for s, _ in cand_rows])
+        picked = []
+        picked_idx = []
+
+        for i in order:
+            if len(picked) >= top_k: break
+            s_i, row_i = cand_rows[i]
+            if not picked:
+                picked.append(row_i)
+                picked_idx.append(i)
+                continue
+            # diversity penalty
+            sim_to_picked = 0.0
+            for j in picked_idx:
+                sim_to_picked = max(sim_to_picked, _cos_sim(cand_embeds[i], cand_embeds[j]))
+            mmr = mmr_lambda * s_i - (1.0 - mmr_lambda) * sim_to_picked
+            # simple thresholding vs worst current; try greedy insert
+            picked.append(row_i)
+            picked_idx.append(i)
+
+        out = pd.DataFrame([r for r in picked]).drop_duplicates().head(top_k).reset_index(drop=True)
+        if out.empty:
+            out = band_df.head(top_k).reset_index(drop=True)
+        out.insert(0, "pick", [1, 2, 3][: len(out)])
+        return out
+    except Exception:
+        # graceful fallback
+        out = band_df.sort_values("mu_capm", ascending=False).head(top_k).reset_index(drop=True)
+        out.insert(0, "pick", [1, 2, 3][: len(out)])
+        return out
 
 # -------------- UI helpers --------------
 def empty_positions_df():
     return pd.DataFrame(columns=["ticker", "amount_usd", "weight_exposure", "beta"])
 
-def empty_suggestion_df():
+def empty_holdings_df():
     return pd.DataFrame(columns=["ticker", "weight_%", "amount_$"])
 
 def set_horizon(years: float):
@@ -371,18 +502,25 @@ def lock_ticker_column(tb: Optional[pd.DataFrame]):
     amounts = amounts[:len(tickers)] + [0.0] * max(0, len(tickers) - len(amounts))
     return pd.DataFrame({"ticker": tickers, "amount_usd": amounts})
 
-# -------------- main compute --------------
+# -------------- compute core --------------
 UNIVERSE: List[str] = [MARKET_TICKER, "QQQ", "VTI", "SOXX", "IBIT"]
 
-def compute(
+def _pick_to_holdings(row: pd.Series, budget: float) -> pd.DataFrame:
+    ts = [t.strip().upper() for t in str(row["tickers"]).split(",")]
+    ws = [float(x) for x in str(row["weights"]).split(",")]
+    s = sum(max(0.0, w) for w in ws) or 1.0
+    ws = [max(0.0, w) / s for w in ws]
+    return pd.DataFrame(
+        [{"ticker": t, "weight_%": round(w * 100.0, 2), "amount_$": round(w * budget, 0)} for t, w in zip(ts, ws)],
+        columns=["ticker", "weight_%", "amount_$"]
+    )
+
+def compute_all(
     years_lookback: int,
     table: Optional[pd.DataFrame],
-    risk_band: str,
-    use_embeddings: bool,
-    pick_idx: int
+    use_embeddings: bool
 ):
-    print("Compute: start")
-    # sanitize table
+    # sanitize input table
     if isinstance(table, pd.DataFrame):
         df = table.copy()
     else:
@@ -395,12 +533,11 @@ def compute(
 
     symbols = [t for t in df["ticker"].tolist() if t]
     if len(symbols) == 0:
-        return None, "Add at least one ticker.", "Universe empty.", empty_positions_df(), empty_suggestion_df(), None, gr.update()
+        raise gr.Error("Add at least one ticker.")
 
     symbols = validate_tickers(symbols, years_lookback)
-    print("Compute: validated", symbols)
     if len(symbols) == 0:
-        return None, "Could not validate any tickers.", "Universe invalid.", empty_positions_df(), empty_suggestion_df(), None, gr.update()
+        raise gr.Error("Could not validate any tickers.")
 
     global UNIVERSE
     UNIVERSE = list(sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER])))[:MAX_TICKERS]
@@ -409,53 +546,56 @@ def compute(
     amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
     rf_ann = RF_ANN
 
-    # Moments
+    # moments
     moms = estimate_all_moments_aligned(symbols, years_lookback, rf_ann)
     betas, covA, erp_ann, sigma_mkt = moms["betas"], moms["cov_ann"], moms["erp_ann"], moms["sigma_m_ann"]
-    print("Compute: moments ok; sigma_mkt=", sigma_mkt, "erp=", erp_ann)
 
-    # Weights
+    # weights
     gross = sum(abs(v) for v in amounts.values())
     if gross <= 1e-12:
-        return None, "All amounts are zero.", "Universe ok.", empty_positions_df(), empty_suggestion_df(), None, gr.update()
+        raise gr.Error("All amounts are zero.")
+
     weights = {k: v / gross for k, v in amounts.items()}
 
-    # Portfolio stats (X uses historical sigma; Y uses CAPM E[r])
+    # portfolio CAPM and σ (historical)
     beta_p, mu_capm, sigma_hist = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
-    sigma_capm = abs(beta_p) * sigma_mkt
 
-    # Efficient alternatives (on CML)
+    # efficient counterparts (market/bills)
     a_sigma, b_sigma, mu_eff_sigma = efficient_same_sigma(sigma_hist, rf_ann, erp_ann, sigma_mkt)
     a_mu, b_mu, sigma_eff_mu = efficient_same_return(mu_capm, rf_ann, erp_ann, sigma_mkt)
 
-    # Synthetic dataset & suggestions
+    # synthetic dataset from current universe
     synth = build_synthetic_dataset(UNIVERSE, covA, betas, rf_ann, erp_ann, sigma_mkt, n_rows=SYNTH_ROWS)
     csv_path = os.path.join(DATA_DIR, f"investor_profiles_{int(time.time())}.csv")
-    synth.to_csv(csv_path, index=False)
-
-    top3 = top3_by_return_in_band(synth, risk_band, sigma_mkt)
-    if use_embeddings:
-        top3 = rerank_with_embeddings(top3, risk_band)
-    if top3.empty:
-        top3 = synth.sort_values("mu_capm", ascending=False).head(3).reset_index(drop=True)
-        top3.insert(0, "pick", [1, 2, 3][: len(top3)])
-
-    idx = max(1, min(3, int(pick_idx))) - 1
-    row = top3.iloc[idx]
+    try:
+        synth.to_csv(csv_path, index=False)
+    except Exception:
+        csv_path = None  # not fatal
+
+    # band splits
+    def band_top3(band: str) -> pd.DataFrame:
+        lo, hi = _band_bounds_sigma_hist(sigma_mkt, band)
+        pick = synth[(synth["sigma_hist"] >= lo) & (synth["sigma_hist"] <= hi)].copy()
+        if pick.empty:
+            pick = synth.copy()
+        # pre-sort by quality then re-rank with embeddings/MMR for diversity
+        pick = pick.sort_values("mu_capm", ascending=False).head(50).reset_index(drop=True)
+        if use_embeddings:
+            user_df = pd.DataFrame({"ticker": list(weights.keys()), "amount_usd": [amounts[t] for t in weights.keys()]})
+            top3 = rerank_band_with_embeddings(user_df, pick, EMBED_ALPHA, MMR_LAMBDA, top_k=3)
+        else:
+            top3 = pick.head(3).reset_index(drop=True)
+            top3.insert(0, "pick", [1, 2, 3][: len(top3)])
+        return top3
 
-    sugg_mu = float(row["mu_capm"])
-    sugg_sigma = float(row["sigma_capm"])
+    top3_low  = band_top3("Low")
+    top3_med  = band_top3("Medium")
+    top3_high = band_top3("High")
 
-    # suggestion holdings (% and $)
-    ts = [t.strip() for t in str(row["tickers"]).split(",")]
-    ws = [float(x) for x in str(row["weights"]).split(",")]
-    s = sum(ws) if ws else 1.0
-    ws = [max(0.0, w) / s for w in ws]
-    budget = gross if gross > 0 else 1.0
-    sugg_table = pd.DataFrame(
-        [{"ticker": t, "weight_%": round(w*100.0, 2), "amount_$": round(w*budget, 0)} for t, w in zip(ts, ws)],
-        columns=["ticker", "weight_%", "amount_$"]
-    )
+    # descriptive tables for each tab
+    low_sum  = _summarize_three(top3_low)
+    med_sum  = _summarize_three(top3_med)
+    high_sum = _summarize_three(top3_high)
 
     # positions table
     pos_table = pd.DataFrame(
@@ -468,51 +608,96 @@ def compute(
         columns=["ticker", "amount_usd", "weight_exposure", "beta"]
     )
 
-    # plot (CAPM on CML; your point uses sigma_hist on X)
-    img = plot_cml(
-        rf_ann, erp_ann, sigma_mkt,
-        sigma_hist, mu_capm,
-        mu_same_sigma=mu_eff_sigma, sigma_same_mu=sigma_eff_mu,
-        sugg_mu=sugg_mu, sugg_sigma=sugg_sigma
-    )
-
+    # summary text
     info = "\n".join([
         "### Inputs",
         f"- Lookback years {years_lookback}",
         f"- Horizon years {int(round(HORIZON_YEARS))}",
         f"- Risk-free {rf_ann:.2%} from {RF_CODE}",
         f"- Market ERP {erp_ann:.2%}",
-        f"- Market σ {sigma_mkt:.2%}",
+        f"- Market σ (hist) {sigma_mkt:.2%}",
         "",
-        "### Your portfolio (CAPM on CML axes)",
+        "### Your portfolio (CAPM on CML; x=σ_hist, y=CAPM E[r])",
         f"- Beta {beta_p:.2f}",
-        f"- Expected return (CAPM / SML) {mu_capm:.2%}",
+        f"- CAPM E[r] {mu_capm:.2%}",
         f"- σ (historical) {sigma_hist:.2%}",
-        f"- σ on CML for same β (|β|×σ_mkt) {sigma_capm:.2%}",
         "",
-        "### Efficient alternatives on CML",
-        f"- Same σ as your portfolio (historical): Market weight {a_sigma:.2f}, Bills weight {b_sigma:.2f}, return {mu_eff_sigma:.2%}",
-        f"- Same return (CAPM): Market weight {a_mu:.2f}, Bills weight {b_mu:.2f}, σ {sigma_eff_mu:.2%}",
+        "### Efficient market/bills mixes",
+        f"- Same σ as your portfolio: Market {a_sigma:.2f}, Bills {b_sigma:.2f} → E[r] {mu_eff_sigma:.2%}",
+        f"- Same E[r] as your portfolio: Market {a_mu:.2f}, Bills {b_mu:.2f} → σ {sigma_eff_mu:.2%}",
         "",
-        "### Dataset-based suggestions (risk: " + risk_band + ")",
-        f"- Showing Pick **#{idx+1}** → CAPM return {sugg_mu:.2%}, CAPM σ {sugg_sigma:.2%}",
-        "",
-        "_Plot shows CAPM E[r] vs σ; your point uses historical σ; efficient references are market/bills on the CML._"
+        "_Plot shows CAPM expectations on the CML with x-axis as **historical σ**._"
     ])
 
     uni_msg = f"Universe set to: {', '.join(UNIVERSE)}"
-    print("Compute: done")
-    return img, info, uni_msg, pos_table, sugg_table, csv_path, gr.update(label=f"Pick #{idx+1} of 3")
 
-# -------------- UI --------------
-def inc_pick(i: int): return min(3, max(1, int(i or 1) + 1))
-def dec_pick(i: int): return max(1, min(3, int(i or 1) - 1))
+    base_outputs = dict(
+        rf_ann=rf_ann, erp_ann=erp_ann, sigma_mkt=sigma_mkt,
+        mu_capm=mu_capm, sigma_hist=sigma_hist,
+        mu_eff_same_sigma=mu_eff_sigma, sigma_eff_same_return=sigma_eff_mu,
+        pos_table=pos_table, info=info, uni_msg=uni_msg,
+        csv_path=csv_path, low_sum=low_sum, med_sum=med_sum, high_sum=high_sum,
+        top3_low=top3_low, top3_med=top3_med, top3_high=top3_high, budget=sum(abs(v) for v in amounts.values())
+    )
+    return base_outputs
+
+def compute_and_render(
+    years_lookback: int,
+    table: Optional[pd.DataFrame],
+    use_embeddings: bool,
+    which_band: str,
+    pick_idx: int
+):
+    outs = compute_all(years_lookback, table, use_embeddings)
+
+    # choose band & pick
+    band = (which_band or "Medium").strip().title()
+    idx = max(1, min(3, int(pick_idx))) - 1
 
-with gr.Blocks(title="Efficient Portfolio Advisor", analytics_enabled=False) as demo:
+    if band == "Low":
+        top3 = outs["top3_low"]
+    elif band == "High":
+        top3 = outs["top3_high"]
+    else:
+        top3 = outs["top3_med"]
+
+    if top3.empty:
+        sugg_mu = None; sugg_sigma_hist = None
+        holdings = empty_holdings_df()
+    else:
+        row = top3.iloc[min(idx, len(top3)-1)]
+        sugg_mu = float(row["mu_capm"])
+        sugg_sigma_hist = float(row["sigma_hist"])
+        holdings = _pick_to_holdings(row, outs["budget"])
+
+    # plot
+    img = plot_cml_hybrid(
+        outs["rf_ann"], outs["erp_ann"], outs["sigma_mkt"],
+        outs["sigma_hist"], outs["mu_capm"],
+        outs["mu_eff_same_sigma"], outs["sigma_eff_same_return"],
+        sugg_mu, sugg_sigma_hist
+    )
+
+    return (
+        img,                          # plot
+        outs["info"],                 # summary
+        outs["uni_msg"],              # universe msg
+        outs["pos_table"],            # positions
+        holdings,                     # selected holdings
+        outs["csv_path"],             # dataset file
+        outs["low_sum"],              # low tab summary (3 picks)
+        outs["med_sum"],              # medium tab summary
+        outs["high_sum"]              # high tab summary
+    )
+
+# -------------- UI --------------
+with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     gr.Markdown(
         "## Efficient Portfolio Advisor\n"
-        "Search symbols, enter **dollar amounts**, set horizon. Returns use Yahoo Finance monthly data; risk-free from FRED. "
-        "Plot shows **CAPM point (E[r]) vs historical σ** plus efficient CML points."
+        "Search symbols, enter **dollar amounts** (negatives allowed), set horizon. "
+        "The plot shows **your CAPM point** on the CML with **x = historical σ** and **y = CAPM E[r] = rf + β·ERP**. "
+        "We also show two efficient market/bills mixes: same σ and same E[r].\n\n"
+        "Suggestions are generated from 1,000 candidate mixes and bucketed by risk (σ)."
     )
 
     with gr.Row():
@@ -520,78 +705,76 @@ with gr.Blocks(title="Efficient Portfolio Advisor", analytics_enabled=False) as
             q = gr.Textbox(label="Search symbol")
             search_note = gr.Markdown()
             matches = gr.Dropdown(choices=[], label="Matches")
-            search_btn = gr.Button("Search")
-            add_btn = gr.Button("Add selected to portfolio")
+            with gr.Row():
+                search_btn = gr.Button("Search")
+                add_btn = gr.Button("Add selected to portfolio")
 
-            gr.Markdown("### Portfolio positions (enter $ amounts; negatives allowed for shorts)")
+            gr.Markdown("### Portfolio positions (enter $ amounts; negatives allowed)")
             table = gr.Dataframe(
-                headers=["ticker", "amount_usd"],
-                datatype=["str", "number"],
-                type="pandas",
-                row_count=0,
-                col_count=(2, "fixed")
+                value=pd.DataFrame(columns=["ticker", "amount_usd"]),
+                interactive=True
             )
 
             horizon = gr.Number(label="Horizon in years (1–100)", value=HORIZON_YEARS, precision=0)
-            lookback = gr.Slider(1, 15, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for betas & covariances")
+            lookback = gr.Slider(1, 15, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years")
+            use_emb = gr.Checkbox(value=True, label="Use finance embeddings + MMR for diverse picks")
 
             gr.Markdown("### Suggestions")
-            risk_band = gr.Radio(["Low", "Medium", "High"], value="Medium", label="Risk tolerance")
-            use_emb = gr.Checkbox(value=True, label="Use finance embeddings to refine picks")
-
-            with gr.Row():
-                prev_btn = gr.Button("◀ Prev")
-                pick_idx = gr.Number(value=1, precision=0, label="Carousel")
-                next_btn = gr.Button("Next ▶")
+            with gr.Tabs():
+                with gr.Tab("Low"):
+                    low_summary = gr.Dataframe(value=empty_holdings_df(), interactive=False, label="Top 3 (Low risk)")
+                    pick_low = gr.Radio(choices=["1", "2", "3"], value="1", label="Select a pick in Low")
+                with gr.Tab("Medium"):
+                    med_summary = gr.Dataframe(value=empty_holdings_df(), interactive=False, label="Top 3 (Medium risk)")
+                    pick_med = gr.Radio(choices=["1", "2", "3"], value="1", label="Select a pick in Medium")
+                with gr.Tab("High"):
+                    high_summary = gr.Dataframe(value=empty_holdings_df(), interactive=False, label="Top 3 (High risk)")
+                    pick_high = gr.Radio(choices=["1", "2", "3"], value="1", label="Select a pick in High")
 
             run_btn = gr.Button("Compute (build dataset & suggest)")
+
         with gr.Column(scale=1):
             plot = gr.Image(label="Capital Market Line (CAPM)", type="pil")
             summary = gr.Markdown(label="Inputs & Results")
             universe_msg = gr.Textbox(label="Universe status", interactive=False)
             positions = gr.Dataframe(
-                label="Computed positions",
-                headers=["ticker", "amount_usd", "weight_exposure", "beta"],
-                datatype=["str", "number", "number", "number"],
-                type="pandas",
-                col_count=(4, "fixed"),
-                value=empty_positions_df(),
-                interactive=False
+                value=empty_positions_df(), interactive=False, label="Computed positions"
             )
-            sugg_table = gr.Dataframe(
-                label="Selected suggestion (carousel) — holdings shown in % and $",
-                headers=["ticker", "weight_%", "amount_$"],
-                datatype=["str", "number", "number"],
-                type="pandas",
-                col_count=(3, "fixed"),
-                value=empty_suggestion_df(),
-                interactive=False
+            selected_table = gr.Dataframe(
+                value=empty_holdings_df(),
+                interactive=False,
+                label="Selected suggestion holdings (% / $)"
             )
             dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
 
-    # wire search / add / locking / horizon
+    # wire: search / add / locking / horizon
     search_btn.click(fn=search_tickers_cb, inputs=q, outputs=[search_note, matches])
     add_btn.click(fn=add_symbol, inputs=[matches, table], outputs=[table, search_note])
     table.change(fn=lock_ticker_column, inputs=table, outputs=table)
     horizon.change(fn=set_horizon, inputs=horizon, outputs=universe_msg)
 
-    # carousel buttons update pick index and then recompute
-    prev_btn.click(fn=dec_pick, inputs=pick_idx, outputs=pick_idx).then(
-        fn=compute,
-        inputs=[lookback, table, risk_band, use_emb, pick_idx],
-        outputs=[plot, summary, universe_msg, positions, sugg_table, dl, pick_idx]
-    )
-    next_btn.click(fn=inc_pick, inputs=pick_idx, outputs=pick_idx).then(
-        fn=compute,
-        inputs=[lookback, table, risk_band, use_emb, pick_idx],
-        outputs=[plot, summary, universe_msg, positions, sugg_table, dl, pick_idx]
+    # main compute (defaults to Medium, pick 1)
+    run_btn.click(
+        fn=compute_and_render,
+        inputs=[lookback, table, use_emb, gr.State("Medium"), gr.State(1)],
+        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_summary, med_summary, high_summary]
     )
 
-    # main compute
-    run_btn.click(
-        fn=compute,
-        inputs=[lookback, table, risk_band, use_emb, pick_idx],
-        outputs=[plot, summary, universe_msg, positions, sugg_table, dl, pick_idx]
+    # band radios trigger recompute with their band + index
+    pick_low.change(
+        fn=compute_and_render,
+        inputs=[lookback, table, use_emb, gr.State("Low"), pick_low],
+        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_summary, med_summary, high_summary]
+    )
+    pick_med.change(
+        fn=compute_and_render,
+        inputs=[lookback, table, use_emb, gr.State("Medium"), pick_med],
+        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_summary, med_summary, high_summary]
+    )
+    pick_high.change(
+        fn=compute_and_render,
+        inputs=[lookback, table, use_emb, gr.State("High"), pick_high],
+        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_summary, med_summary, high_summary]
     )
 
 # initialize risk-free at launch
@@ -599,10 +782,11 @@ RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
 RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
 if __name__ == "__main__":
-    # IMPORTANT for Spaces/Docker: bind to 0.0.0.0 and the correct PORT
-    demo.queue(concurrency_count=8).launch(
+    # Gradio 5.x: no concurrency_count on .queue()
+    demo.queue()
+    demo.launch(
         server_name="0.0.0.0",
-        server_port=int(os.environ.get("PORT", "7860")),
-        show_error=True,
-        share=False
+        server_port=int(os.environ.get("PORT", 7860)),
+        show_api=False,
+        share=False,
     )