Update app.py

app.py

@@ -1,16 +1,12 @@
 # app.py
-# Efficient Portfolio Advisor — CAPM-on-CML plot + 1,000-mix dataset + 3x3 suggestions
-# - X axis: historical sigma (from covariances over lookback)
-# - Y axis: CAPM E[r] = rf + beta * ERP
-# - Plot includes two efficient CML mixes: same-σ and same-μ as the user portfolio
-# - Dataset: 1,000 long-only candidate mixes from *current* universe (incl. VOO)
-# - Suggestions: Tabs Low/Medium/High, 3 picks each, chosen by exposure+embedding sim with MMR
-# - Embeddings: FinLang/finance-embeddings-investopedia
-# - Score = α * exposure_similarity + (1-α) * embedding_similarity (α=0.6); MMR λ=0.7
-# - CSV of dataset downloadable.
-import os, io, math, time, json, warnings
+import os, io, math, time, warnings
 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
@@ -27,19 +23,14 @@ os.makedirs(DATA_DIR, exist_ok=True)
 
 MAX_TICKERS = 30
 DEFAULT_LOOKBACK_YEARS = 10
-MARKET_TICKER = "VOO"       # market proxy on CML
-BILLS_LABEL  = "Bills"      # label for risk-free leg in efficient mixes (display only)
+MARKET_TICKER = "VOO"
 
-SYNTH_ROWS = 1000           # dataset size for suggestions
-EMB_MODEL = "FinLang/finance-embeddings-investopedia"
-ALPHA = 0.60                # exposure-vs-embedding blend
-MMR_LAMBDA = 0.70           # MMR diversity strength
-SHORTLIST_K = 40            # shortlist before MMR per band
+SYNTH_ROWS = 1000  # size of generated dataset for suggestions
 
-# Globals updated with horizon changes
+# Globals that update with horizon changes
 HORIZON_YEARS = 10
 RF_CODE = "DGS10"
-RF_ANN = 0.0375  # initialized at launch
+RF_ANN = 0.0375  # updated at launch
 
 # ---------------- helpers ----------------
 def fred_series_for_horizon(years: float) -> str:
@@ -70,7 +61,8 @@ def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
 
     df = yf.download(
         tickers,
-        start=start, end=end,
+        start=start,
+        end=end,
         interval="1mo",
         auto_adjust=True,
         actions=False,
@@ -79,7 +71,7 @@ def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
         threads=False,
     )
 
-    # Normalize to: columns = tickers, values = prices
+    # Normalize to wide frame of prices (one column per ticker)
     if isinstance(df, pd.Series):
         df = df.to_frame()
     if isinstance(df.columns, pd.MultiIndex):
@@ -126,7 +118,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 []  # need market for aligned CAPM
+        return []
     return ok
 
 # -------------- aligned moments --------------
@@ -189,9 +181,8 @@ def portfolio_stats(weights: Dict[str, float],
     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
+    return beta_p, mu_capm, sigma_hist  # <-- X uses HIST sigma
 
-# -------------- efficient CML mixes --------------
 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
@@ -205,11 +196,15 @@ def efficient_same_return(mu_target: float, rf_ann: float, erp_ann: float, sigma
     return a, 1.0 - a, abs(a) * sigma_mkt
 
 # -------------- plotting (CAPM on CML) --------------
-def _pct(x): return np.asarray(x, dtype=float) * 100.0
-
-def plot_cml(rf_ann, erp_ann, sigma_mkt,
-             sigma_hist, mu_capm,
-             sugg_mu=None, sugg_sigma=None) -> Image.Image:
+def _pct(x):
+    return np.asarray(x, dtype=float) * 100.0
+
+def plot_cml(
+    rf_ann, erp_ann, sigma_mkt,
+    sigma_hist, mu_capm,
+    mu_same_sigma, sigma_same_mu,
+    sugg_mu=None, sugg_sigma=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)
@@ -218,9 +213,15 @@ def plot_cml(rf_ann, erp_ann, sigma_mkt,
 
     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 (VOO)")
+    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)
 
@@ -235,7 +236,7 @@ def plot_cml(rf_ann, erp_ann, sigma_mkt,
     buf.seek(0)
     return Image.open(buf)
 
-# -------------- synthetic dataset (from current universe) --------------
+# -------------- synthetic dataset --------------
 def build_synthetic_dataset(universe: List[str],
                             covA: pd.DataFrame,
                             betas: Dict[str, float],
@@ -244,23 +245,19 @@ def build_synthetic_dataset(universe: List[str],
                             sigma_mkt: float,
                             n_rows: int = SYNTH_ROWS) -> pd.DataFrame:
     rng = np.random.default_rng(12345)
-    U = list(universe)
-    if not U:
-        U = [MARKET_TICKER]
+    assets = [t for t in universe if t != MARKET_TICKER]
+    if not assets:
+        assets = [MARKET_TICKER]
 
     rows = []
-    for i in range(n_rows):
-        k = int(rng.integers(low=2, high=min(8, len(U)) + 1))
-        picks = list(rng.choice(U, size=k, replace=False))
-        w = rng.dirichlet(np.ones(k))           # long-only, sums to 1
-
+    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))
+        w = rng.dirichlet(np.ones(k))
         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
-
-        # CAPM "equivalent" sigma on CML for the same expected return
         sigma_capm = abs(beta_p) * sigma_mkt
 
         rows.append({
@@ -273,140 +270,48 @@ def build_synthetic_dataset(universe: List[str],
         })
     return pd.DataFrame(rows)
 
-# -------------- banding by σ (CAPM) --------------
 def _band_bounds(sigma_mkt: float, band: str) -> Tuple[float, float]:
-    b = (band or "Medium").strip().lower()
-    if b.startswith("low"):   return 0.0, 0.8 * sigma_mkt
-    if b.startswith("high"):  return 1.2 * sigma_mkt, 3.0 * sigma_mkt
+    band = (band or "Medium").strip().lower()
+    if band.startswith("low"):
+        return 0.0, 0.8 * sigma_mkt
+    if band.startswith("high"):
+        return 1.2 * sigma_mkt, 3.0 * sigma_mkt
     return 0.8 * sigma_mkt, 1.2 * sigma_mkt
 
-def slice_band(df: pd.DataFrame, band: str, sigma_mkt: float) -> pd.DataFrame:
+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()
-    return pick if not pick.empty else df.copy()
-
-# -------------- embeddings + exposure similarity + MMR --------------
-_embedder = None
-def get_embedder():
-    global _embedder
-    if _embedder is None:
+    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:
+    try:
         from sentence_transformers import SentenceTransformer
-        _embedder = SentenceTransformer(EMB_MODEL)
-    return _embedder
-
-def _weights_dict_from_row(r: pd.Series) -> Dict[str, float]:
-    ts = [t.strip().upper() for t in str(r["tickers"]).split(",")]
-    ws = [float(x) for x in str(r["weights"]).split(",")]
-    wmap = {ts[i]: ws[i] for i in range(min(len(ts), len(ws)))}
-    s = sum(wmap.values()) or 1.0
-    return {k: max(0.0, v) / s for k, v in wmap.items()}  # ensure long-only normalized
-
-def _aligned_vec(universe: List[str], wmap: Dict[str, float]) -> np.ndarray:
-    # vector in the same order
-    return np.array([float(wmap.get(t, 0.0)) for t in universe], dtype=float)
-
-def cosine_sim(a: np.ndarray, b: np.ndarray) -> float:
-    na = np.linalg.norm(a); nb = np.linalg.norm(b)
-    if na == 0 or nb == 0: return 0.0
-    return float(np.dot(a, b) / (na * nb))
-
-def portfolio_embedding(weights: Dict[str, float]) -> np.ndarray:
-    # weighted average of ticker embeddings
-    model = get_embedder()
-    toks = list(weights.keys())
-    if not toks: return np.zeros((get_embedder().get_sentence_embedding_dimension(),), dtype=float)
-    embs = model.encode(toks, convert_to_numpy=True, normalize_embeddings=True)
-    w = np.array([weights[t] for t in toks], dtype=float)
-    w = w / (w.sum() or 1.0)
-    vec = (embs * w[:, None]).sum(axis=0)
-    # normalize
-    n = np.linalg.norm(vec)
-    return vec / (n if n else 1.0)
-
-def mmr(query_vec: np.ndarray, cand_vecs: np.ndarray, k: int, lam: float) -> List[int]:
-    # classic MMR on cosine sim
-    if len(cand_vecs) <= k: return list(range(len(cand_vecs)))
-    sims_q = cand_vecs @ query_vec
-    chosen = [int(np.argmax(sims_q))]
-    candidates = set(range(len(cand_vecs))) - set(chosen)
-    while len(chosen) < k and candidates:
-        best_i, best_score = None, -1e9
-        for i in list(candidates):
-            sim_q = sims_q[i]
-            sim_d = max(float(cand_vecs[i] @ cand_vecs[j]) for j in chosen)
-            score = lam * sim_q - (1.0 - lam) * sim_d
-            if score > best_score:
-                best_score = score; best_i = i
-        chosen.append(best_i); candidates.remove(best_i)
-    return chosen
-
-def pick_3_for_band(synth: pd.DataFrame,
-                    band: str,
-                    sigma_mkt: float,
-                    uni: List[str],
-                    user_w: Dict[str, float]) -> Tuple[List[Dict], List[pd.DataFrame]]:
-    # shortlist by top CAPM returns within band
-    band_df = slice_band(synth, band, sigma_mkt)
-    band_df = band_df.sort_values("mu_capm", ascending=False).head(SHORTLIST_K).reset_index(drop=True)
-    if band_df.empty:
-        return [], []
-
-    # exposure vectors
-    user_vec = _aligned_vec(uni, user_w)
-
-    # portfolio embedding
-    q_emb = portfolio_embedding(user_w)
-
-    # candidate embeddings (weighted avg of ticker embeddings)
-    c_wmaps = [ _weights_dict_from_row(r) for _, r in band_df.iterrows() ]
-    toks_list = [list(wm.keys()) for wm in c_wmaps]
-    # flatten encode unique tokens once
-    tok_set = sorted(set(t for toks in toks_list for t in toks))
-    model = get_embedder()
-    tok_embs = model.encode(tok_set, convert_to_numpy=True, normalize_embeddings=True)
-    tok_idx = {t:i for i,t in enumerate(tok_set)}
-
-    cand_vecs = []
-    expo_sims = []
-    for wm in c_wmaps:
-        # exposure sim (cosine on aligned vectors)
-        c_vec = _aligned_vec(uni, wm)
-        expo_sims.append(cosine_sim(user_vec, c_vec))
-        # weighted-avg ticker embedding
-        if wm:
-            w = np.array([wm[t] for t in wm.keys()], dtype=float)
-            w = w / (w.sum() or 1.0)
-            e = np.vstack([tok_embs[tok_idx[t]] for t in wm.keys()])
-            v = (e * w[:,None]).sum(axis=0)
-            v = v / (np.linalg.norm(v) or 1.0)
-            cand_vecs.append(v)
-        else:
-            cand_vecs.append(np.zeros_like(tok_embs[0]))
-
-    cand_vecs = np.vstack(cand_vecs)
-    # embedding sim: dot with q_emb (already normalized)
-    emb_sims = cand_vecs @ q_emb
-
-    # blended score
-    scores = ALPHA * np.array(expo_sims) + (1.0 - ALPHA) * np.array(emb_sims)
-    short_idx = np.argsort(-scores)[:min(12, len(scores))]
-
-    # MMR on the short list to get 3 diverse
-    mmr_idx_local = mmr(q_emb, cand_vecs[short_idx], k=3, lam=MMR_LAMBDA)
-    chosen = [int(short_idx[i]) for i in mmr_idx_local]
-    picks = band_df.iloc[chosen].reset_index(drop=True)
-
-    # tables (% and $) for each pick
-    gross_amt = sum(abs(v) for v in user_w.values()) or 1.0
-    tbls = []
-    metas = []
-    for _, r in picks.iterrows():
-        wm = _weights_dict_from_row(r)
-        rows = [{"ticker": t, "weight_%": round(w*100.0, 2), "amount_$": round(w*gross_amt, 2)} for t, w in wm.items()]
-        df = pd.DataFrame(rows, columns=["ticker", "weight_%", "amount_$"]).sort_values("weight_%", ascending=False)
-        tbls.append(df.reset_index(drop=True))
-        metas.append({"mu": float(r["mu_capm"]), "sigma": float(r["sigma_capm"])})
-    return metas, tbls
+        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)
+    except Exception:
+        return top3
 
 # -------------- UI helpers --------------
 def empty_positions_df():
@@ -472,93 +377,87 @@ UNIVERSE: List[str] = [MARKET_TICKER, "QQQ", "VTI", "SOXX", "IBIT"]
 def compute(
     years_lookback: int,
     table: Optional[pd.DataFrame],
-    pick_low: int,
-    pick_med: int,
-    pick_high: int
+    risk_band: str,
+    use_embeddings: bool,
+    pick_idx: int
 ):
+    print("Compute: start")
     # sanitize table
     if isinstance(table, pd.DataFrame):
         df = table.copy()
     else:
         df = pd.DataFrame(columns=["ticker", "amount_usd"])
     df = df.dropna(how="all")
-    for col in ("ticker","amount_usd"):
-        if col not in df.columns: df[col] = []
+    if "ticker" not in df.columns: df["ticker"] = []
+    if "amount_usd" not in df.columns: df["amount_usd"] = []
     df["ticker"] = df["ticker"].astype(str).str.upper().str.strip()
     df["amount_usd"] = pd.to_numeric(df["amount_usd"], errors="coerce").fillna(0.0)
 
     symbols = [t for t in df["ticker"].tolist() if t]
     if len(symbols) == 0:
-        empty = empty_positions_df()
-        e = "Add at least one ticker."
-        return None, e, "Universe empty.", empty, empty_suggestion_df(), empty_suggestion_df(), empty_suggestion_df(), empty_suggestion_df(), empty_suggestion_df(), empty_suggestion_df(), json.dumps({}), e
+        return None, "Add at least one ticker.", "Universe empty.", empty_positions_df(), empty_suggestion_df(), None, gr.update()
 
     symbols = validate_tickers(symbols, years_lookback)
+    print("Compute: validated", symbols)
     if len(symbols) == 0:
-        empty = empty_positions_df()
-        e = "Could not validate any tickers."
-        return None, e, "Universe invalid.", empty, empty_suggestion_df(), empty_suggestion_df(), empty_suggestion_df(), empty_suggestion_df(), empty_suggestion_df(), empty_suggestion_df(), json.dumps({}), e
+        return None, "Could not validate any tickers.", "Universe invalid.", empty_positions_df(), empty_suggestion_df(), None, gr.update()
 
     global UNIVERSE
     UNIVERSE = list(sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER])))[:MAX_TICKERS]
 
     df = df[df["ticker"].isin(symbols)].copy()
     amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
-    gross = sum(abs(v) for v in amounts.values())
-    if gross <= 1e-12:
-        empty = empty_positions_df()
-        e = "All amounts are zero."
-        return None, e, "Universe ok.", empty, *(empty_suggestion_df() for _ in range(6)), json.dumps({}), e
-
-    weights = {k: v / gross for k, v in amounts.items()}
     rf_ann = RF_ANN
 
     # 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)
 
-    # Portfolio CAPM stats (Y) vs historical σ (X)
+    # 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()
+    weights = {k: v / gross for k, v in amounts.items()}
+
+    # Portfolio stats (X uses historical sigma; Y uses CAPM E[r])
     beta_p, mu_capm, sigma_hist = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
-    sigma_capm = abs(beta_p) * sigma_mkt  # for info only
+    sigma_capm = abs(beta_p) * sigma_mkt
 
-    # Efficient alternatives on CML
+    # Efficient alternatives (on CML)
     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)
 
-    # Dataset (1,000 mixes) and save CSV
+    # Synthetic dataset & suggestions
     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")
-    try:
-        synth.to_csv(csv_path, index=False)
-    except Exception:
-        csv_path = None
-
-    # Picks per band (Low/Medium/High)
-    meta_low,  tbls_low  = pick_3_for_band(synth, "Low",    sigma_mkt, UNIVERSE, weights)
-    meta_med,  tbls_med  = pick_3_for_band(synth, "Medium", sigma_mkt, UNIVERSE, weights)
-    meta_high, tbls_high = pick_3_for_band(synth, "High",   sigma_mkt, UNIVERSE, weights)
-
-    # fallbacks if any band empty
-    def ensure_three(meta, tbls):
-        while len(meta) < 3:
-            meta.append({"mu": mu_capm, "sigma": sigma_capm})
-            tbls.append(empty_suggestion_df())
-        return meta[:3], tbls[:3]
-
-    meta_low,  tbls_low  = ensure_three(meta_low,  tbls_low)
-    meta_med,  tbls_med  = ensure_three(meta_med,  tbls_med)
-    meta_high, tbls_high = ensure_three(meta_high, tbls_high)
-
-    # clamp pick indices to 1..3
-    pick_low  = int(max(1, min(3, pick_low or 1)))
-    pick_med  = int(max(1, min(3, pick_med or 1)))
-    pick_high = int(max(1, min(3, pick_high or 1)))
-
-    # default highlighted suggestion: Medium / chosen index
-    sel = meta_med[pick_med-1]
-    img = plot_cml(rf_ann, erp_ann, sigma_mkt, sigma_hist, mu_capm, sel["mu"], sel["sigma"])
-
-    # positions table (computed)
+    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]
+
+    sugg_mu = float(row["mu_capm"])
+    sugg_sigma = float(row["sigma_capm"])
+
+    # 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_$"]
+    )
+
+    # positions table
     pos_table = pd.DataFrame(
         [{
             "ticker": t,
@@ -569,17 +468,14 @@ def compute(
         columns=["ticker", "amount_usd", "weight_exposure", "beta"]
     )
 
-    # efficient mixes tables (display-only)
-    eff_same_sigma_tbl = pd.DataFrame([
-        {"ticker": MARKET_TICKER, "weight_%": round(a_sigma*100,2), "amount_$": round(a_sigma*gross,2)},
-        {"ticker": BILLS_LABEL,   "weight_%": round(b_sigma*100,2), "amount_$": round(b_sigma*gross,2)},
-    ])
-    eff_same_mu_tbl = pd.DataFrame([
-        {"ticker": MARKET_TICKER, "weight_%": round(a_mu*100,2), "amount_$": round(a_mu*gross,2)},
-        {"ticker": BILLS_LABEL,   "weight_%": round(b_mu*100,2), "amount_$": round(b_mu*gross,2)},
-    ])
+    # 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
+    )
 
-    # info summary
     info = "\n".join([
         "### Inputs",
         f"- Lookback years {years_lookback}",
@@ -588,68 +484,35 @@ def compute(
         f"- Market ERP {erp_ann:.2%}",
         f"- Market σ {sigma_mkt:.2%}",
         "",
-        "### Your portfolio (CAPM on CML plot)",
+        "### Your portfolio (CAPM on CML axes)",
         f"- Beta {beta_p:.2f}",
         f"- Expected return (CAPM / SML) {mu_capm:.2%}",
         f"- σ (historical) {sigma_hist:.2%}",
+        f"- σ on CML for same β (|β|×σ_mkt) {sigma_capm:.2%}",
         "",
         "### Efficient alternatives on CML",
-        f"- Same σ: Market {a_sigma:.2f}, Bills {b_sigma:.2f}, E[r] {mu_eff_sigma:.2%}",
-        f"- Same μ: Market {a_mu:.2f}, Bills {b_mu:.2f}, σ {sigma_eff_mu:.2%}",
+        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%}",
+        "",
+        "### Dataset-based suggestions (risk: " + risk_band + ")",
+        f"- Showing Pick **#{idx+1}** → CAPM return {sugg_mu:.2%}, CAPM σ {sugg_sigma:.2%}",
         "",
-        "### Suggestions",
-        "Three tabs (Low/Medium/High). Select a pick to highlight it on the plot.",
-        "_Plot is **always** CAPM E[r] vs historical σ; your CAPM point will never exceed the CML._"
+        "_Plot shows CAPM E[r] vs σ; your point uses historical σ; efficient references are market/bills on the CML._"
     ])
 
-    # pack suggestion meta for quick plot refresh on band selection
-    meta = {
-        "low":   meta_low,
-        "med":   meta_med,
-        "high":  meta_high,
-        "plot":  {"rf": rf_ann, "erp": erp_ann, "sigma_mkt": sigma_mkt, "sigma_hist": sigma_hist, "mu_capm": mu_capm}
-    }
-
     uni_msg = f"Universe set to: {', '.join(UNIVERSE)}"
-
-    # outputs:
-    # plot, summary, universe, positions,
-    # low tables (3), medium tables (3), high tables (3),
-    # efficient tables (same σ, same μ),
-    # meta json, status
-    return (
-        img, info, uni_msg, pos_table,
-        tbls_low[0], tbls_low[1], tbls_low[2],
-        tbls_med[0], tbls_med[1], tbls_med[2],
-        tbls_high[0], tbls_high[1], tbls_high[2],
-        eff_same_sigma_tbl, eff_same_mu_tbl,
-        json.dumps(meta), (csv_path or "")
-    )
-
-def highlight_from_pick(meta_json: str, band: str, pick_idx: int):
-    try:
-        meta = json.loads(meta_json)
-        plotp = meta.get("plot", {})
-        rf = float(plotp["rf"]); erp = float(plotp["erp"]); sigma_mkt = float(plotp["sigma_mkt"])
-        sigma_hist = float(plotp["sigma_hist"]); mu_capm = float(plotp["mu_capm"])
-        arr = meta["low" if band=="Low" else "med" if band=="Medium" else "high"]
-        i = int(max(1, min(3, pick_idx or 1))) - 1
-        sel = arr[i]
-        return plot_cml(rf, erp, sigma_mkt, sigma_hist, mu_capm, sel["mu"], sel["sigma"])
-    except Exception as e:
-        # if anything fails, fall back to no suggestion highlighted
-        return None
+    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 clamp13(i: int): return int(max(1, min(3, int(i or 1))))
+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))
 
-with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
+with gr.Blocks(title="Efficient Portfolio Advisor", analytics_enabled=False) as demo:
     gr.Markdown(
         "## Efficient Portfolio Advisor\n"
-        "Search symbols, enter **dollar amounts**, set horizon. Data uses Yahoo monthly prices; risk-free from FRED.\n\n"
-        "**Plot:** CAPM E[r] vs historical σ on the **CML**.\n"
-        "**Efficient mixes:** CML portfolio with **same σ** and CML portfolio with **same E[r]** as yours.\n"
-        "**Suggestions:** 1,000 long-only mixes from your universe → 3 picks per risk band using exposure+embeddings with MMR diversity."
+        "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."
     )
 
     with gr.Row():
@@ -660,65 +523,51 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
             search_btn = gr.Button("Search")
             add_btn = gr.Button("Add selected to portfolio")
 
-            gr.Markdown("### Portfolio positions (enter $ amounts; negatives allowed for your input)")
+            gr.Markdown("### Portfolio positions (enter $ amounts; negatives allowed for shorts)")
             table = gr.Dataframe(
                 headers=["ticker", "amount_usd"],
                 datatype=["str", "number"],
+                type="pandas",
                 row_count=0,
-                col_count=(2, "fixed"),
-                type="pandas"   # Gradio 5-friendly
+                col_count=(2, "fixed")
             )
 
             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")
 
+            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 ▶")
+
             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 / Horizon", interactive=False)
-
+            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,
-                type="pandas"
+                interactive=False
             )
-
-    # Suggestions area: three tabs, each 3 picks
-    meta_box = gr.Textbox(value="{}", visible=False, label="meta")
-    csv_path = gr.File(label="Generated dataset CSV", value=None, visible=True)
-
-    with gr.Tab("Low"):
-        with gr.Row():
-            low1 = gr.Dataframe(label="Pick #1", interactive=False, type="pandas")
-            low2 = gr.Dataframe(label="Pick #2", interactive=False, type="pandas")
-            low3 = gr.Dataframe(label="Pick #3", interactive=False, type="pandas")
-        pick_low = gr.Slider(1, 3, value=1, step=1, label="Highlight pick")
-        low_btn = gr.Button("Show on plot")
-
-    with gr.Tab("Medium"):
-        with gr.Row():
-            med1 = gr.Dataframe(label="Pick #1", interactive=False, type="pandas")
-            med2 = gr.Dataframe(label="Pick #2", interactive=False, type="pandas")
-            med3 = gr.Dataframe(label="Pick #3", interactive=False, type="pandas")
-        pick_med = gr.Slider(1, 3, value=1, step=1, label="Highlight pick")
-        med_btn = gr.Button("Show on plot")
-
-    with gr.Tab("High"):
-        with gr.Row():
-            high1 = gr.Dataframe(label="Pick #1", interactive=False, type="pandas")
-            high2 = gr.Dataframe(label="Pick #2", interactive=False, type="pandas")
-            high3 = gr.Dataframe(label="Pick #3", interactive=False, type="pandas")
-        pick_high = gr.Slider(1, 3, value=1, step=1, label="Highlight pick")
-        high_btn = gr.Button("Show on plot")
-
-    gr.Markdown("### Efficient alternatives on the CML")
-    eff_same_sigma_tbl = gr.Dataframe(label="Efficient: Same σ", interactive=False, type="pandas")
-    eff_same_mu_tbl    = gr.Dataframe(label="Efficient: Same μ", interactive=False, type="pandas")
+            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
+            )
+            dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
 
     # wire search / add / locking / horizon
     search_btn.click(fn=search_tickers_cb, inputs=q, outputs=[search_note, matches])
@@ -726,29 +575,34 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     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
     run_btn.click(
         fn=compute,
-        inputs=[lookback, table, gr.State(1), gr.State(1), gr.State(1)],
-        outputs=[
-            plot, summary, universe_msg, positions,
-            low1, low2, low3,
-            med1, med2, med3,
-            high1, high2, high3,
-            eff_same_sigma_tbl, eff_same_mu_tbl,
-            meta_box, csv_path
-        ]
+        inputs=[lookback, table, risk_band, use_emb, pick_idx],
+        outputs=[plot, summary, universe_msg, positions, sugg_table, dl, pick_idx]
     )
 
-    # highlight buttons refresh plot with selected suggestion
-    low_btn.click(fn=highlight_from_pick, inputs=[meta_box, gr.State("Low"),  pick_low],  outputs=plot)
-    med_btn.click(fn=highlight_from_pick, inputs=[meta_box, gr.State("Medium"), pick_med], outputs=plot)
-    high_btn.click(fn=highlight_from_pick, inputs=[meta_box, gr.State("High"), pick_high], outputs=plot)
-
 # initialize risk-free at launch
 RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
 RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
 if __name__ == "__main__":
-    # On Hugging Face Spaces you don't need share=True; binding to 0.0.0.0 is fine
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    # IMPORTANT for Spaces/Docker: bind to 0.0.0.0 and the correct PORT
+    demo.queue(concurrency_count=8).launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", "7860")),
+        show_error=True,
+        share=False
+    )