Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py (CML-safe: sigma uses full cov incl. market)
+# app.py — Efficient Portfolio Advisor (CML-safe, same-ticker suggestions, embeddings always on)
 import os, io, math, time, warnings
 warnings.filterwarnings("ignore")
 
@@ -22,8 +22,8 @@ MARKET_TICKER = "VOO"
 
 SYNTH_ROWS = 1000
 EMBED_MODEL_NAME = "FinLang/finance-embeddings-investopedia"
-EMBED_ALPHA = 0.6
-MMR_LAMBDA = 0.7
+EMBED_ALPHA = 0.6   # exposure similarity weight
+MMR_LAMBDA = 0.7    # diversity for re-ranking (kept for consistency even though we output 1 per band)
 
 HORIZON_YEARS = 10
 RF_CODE = "DGS10"
@@ -126,7 +126,7 @@ def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
         betas[s] = cov_sm / var_m
     betas[MARKET_TICKER] = 1.0
 
-    # FULL covariance including MARKET_TICKER (crucial to keep points ≤ CML)
+    # Full covariance including MARKET_TICKER
     cov_all_ann = pd.DataFrame(np.cov(R.values.T, ddof=1) * 12.0,
                                index=R.columns, columns=R.columns)
 
@@ -186,19 +186,19 @@ def plot_cml_hybrid(rf_ann, erp_ann, sigma_mkt,
     buf = io.BytesIO(); plt.savefig(buf, format="png"); plt.close(fig); buf.seek(0)
     return Image.open(buf)
 
-# -------------- synthetic dataset (σ uses FULL cov) --------------
-def build_synthetic_dataset(universe: List[str],
-                            cov_all_ann: pd.DataFrame,
-                            betas: Dict[str, float],
-                            rf_ann: float,
-                            erp_ann: float,
-                            n_rows: int = SYNTH_ROWS) -> pd.DataFrame:
+# -------------- synthetic dataset (re-weights of SAME tickers) --------------
+def build_synthetic_dataset_same_tickers(tickers: List[str],
+                                         cov_all_ann: pd.DataFrame,
+                                         betas: Dict[str, float],
+                                         rf_ann: float,
+                                         erp_ann: float,
+                                         n_rows: int = SYNTH_ROWS) -> pd.DataFrame:
+    """Generate long-only Dirichlet weights over EXACTLY the user's tickers."""
     rng = np.random.default_rng(12345)
-    if MARKET_TICKER not in universe: universe = list(universe) + [MARKET_TICKER]
+    picks = [t for t in tickers]  # fixed set
+    k = len(picks)
     rows = []
     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)
@@ -219,16 +219,7 @@ def _band_bounds_sigma_hist(sigma_mkt: float, band: str) -> Tuple[float, float]:
     if band.startswith("high"): return 1.2 * sigma_mkt, 3.0 * sigma_mkt
     return 0.8 * sigma_mkt, 1.2 * sigma_mkt
 
-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).round(2),
-                        "σ (hist) %": (out["sigma_hist"]*100).round(2),
-                        "tickers": out["tickers"]})[["CAPM E[r] %","σ (hist) %","tickers"]]
-    out = out.reset_index(drop=True); out.insert(0, "pick", [1,2,3][:len(out)])
-    return out
-
-# -------------- embeddings & re-ranking --------------
+# -------------- embeddings & scoring --------------
 _EMBED_MODEL = None
 _TICKER_EMBED_CACHE: Dict[str, np.ndarray] = {}
 
@@ -272,48 +263,38 @@ def _exposure_similarity(user_map: Dict[str,float], cand_map: Dict[str,float]) -
     c = {k:abs(v)/s_c for k,v in cand_map.items()}
     common = set(u)&set(c); 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:
+def pick_best_in_band(user_df: pd.DataFrame, band_df: pd.DataFrame,
+                      alpha: float = EMBED_ALPHA, top_N: int = 50) -> pd.Series:
+    """
+    Score candidates by alpha*exposure-sim + (1-alpha)*embedding-sim, among top_N by CAPM return.
+    Return the single best row.
+    """
+    if band_df.empty: return pd.Series(dtype="float64")
     try:
+        # restrict to strong candidates by return first
+        band_df = band_df.sort_values("mu_capm", ascending=False).head(top_N).reset_index(drop=True)
+
         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)
 
-        cand_rows = []; cand_embeds = []
+        scores = []
         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(",")]
             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)
+            c_embed = _portfolio_embedding(ts, ws)
             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)
-
-        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
-            sim_to_picked = max(_cos_sim(cand_embeds[i], cand_embeds[j]) for j in picked_idx)
-            mmr = mmr_lambda*s_i - (1.0-mmr_lambda)*sim_to_picked  # noqa: F841 (kept for clarity)
-            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
+            scores.append(alpha*expo_sim + (1.0-alpha)*emb_sim)
+
+        i_best = int(np.argmax(scores))
+        return band_df.iloc[i_best]
     except Exception:
-        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
+        return band_df.iloc[0]
 
 # -------------- UI helpers --------------
 def empty_positions_df(): return pd.DataFrame(columns=["ticker","amount_usd","weight_exposure","beta"])
@@ -364,7 +345,8 @@ def lock_ticker_column(tb: Optional[pd.DataFrame]):
 # -------------- compute core --------------
 UNIVERSE: List[str] = [MARKET_TICKER, "QQQ", "VTI", "SOXX", "IBIT"]
 
-def _pick_to_holdings(row: pd.Series, budget: float) -> pd.DataFrame:
+def _row_to_holdings(row: pd.Series, budget: float) -> pd.DataFrame:
+    if row is None or row.empty: return empty_holdings_df()
     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
@@ -372,20 +354,23 @@ def _pick_to_holdings(row: pd.Series, budget: float) -> pd.DataFrame:
     return pd.DataFrame([{"ticker": t, "weight_%": round(w*100,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], use_embeddings: bool):
+def compute_all(years_lookback: int, table: Optional[pd.DataFrame]):
+    # sanitize input table
     df = table.copy() if isinstance(table,pd.DataFrame) else pd.DataFrame(columns=["ticker","amount_usd"])
     df = df.dropna(how="all")
     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: raise gr.Error("Add at least one ticker.")
     symbols = validate_tickers(symbols, years_lookback)
     if len(symbols)==0: raise gr.Error("Could not validate any tickers.")
 
     global UNIVERSE
-    UNIVERSE = list(sorted(set([s for s in symbols] + [MARKET_TICKER])))[:MAX_TICKERS]
+    # Universe is your exact tickers (for suggestions we re-weight SAME tickers)
+    UNIVERSE = list(sorted(set(symbols)))[:MAX_TICKERS]
 
     df = df[df["ticker"].isin(symbols)].copy()
     amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
@@ -403,30 +388,29 @@ def compute_all(years_lookback: int, table: Optional[pd.DataFrame], use_embeddin
     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)
 
-    synth = build_synthetic_dataset(UNIVERSE, cov_all_ann, betas, rf_ann, erp_ann, n_rows=SYNTH_ROWS)
+    # dataset: re-weight EXACT same tickers you entered
+    synth = build_synthetic_dataset_same_tickers(UNIVERSE, cov_all_ann, betas, rf_ann, erp_ann, 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
 
-    def band_top3(band: str) -> pd.DataFrame:
+    # one suggestion per band (best by embedding/exposure score among candidates in band)
+    def best_for_band(band: str) -> pd.Series:
         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()
-        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
-
-    top3_low, top3_med, top3_high = band_top3("Low"), band_top3("Medium"), band_top3("High")
-    low_sum, med_sum, high_sum = _summarize_three(top3_low), _summarize_three(top3_med), _summarize_three(top3_high)
+        band_df = synth[(synth["sigma_hist"]>=lo) & (synth["sigma_hist"]<=hi)].copy()
+        if band_df.empty: band_df = synth.copy()
+        user_df = pd.DataFrame({"ticker": list(weights.keys()), "amount_usd": [amounts[t] for t in weights.keys()]})
+        return pick_best_in_band(user_df, band_df, EMBED_ALPHA, top_N=50)
+
+    best_low = best_for_band("Low")
+    best_med = best_for_band("Medium")
+    best_high = best_for_band("High")
 
+    # derived displays
     pos_table = pd.DataFrame([{
         "ticker": t, "amount_usd": amounts.get(t,0.0),
         "weight_exposure": weights.get(t,0.0),
-        "beta": 1.0 if t==MARKET_TICKER else betas.get(t, np.nan)
+        "beta": betas.get(t, np.nan) if t != MARKET_TICKER else 1.0
     } for t in symbols], columns=["ticker","amount_usd","weight_exposure","beta"])
 
     info = "\n".join([
@@ -446,6 +430,7 @@ def compute_all(years_lookback: int, table: Optional[pd.DataFrame], use_embeddin
         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%}",
         "",
+        "_Suggestions are single picks per band, re-weighting **the same tickers you entered**, and are chosen via embeddings + exposure similarity._",
         "_All points are guaranteed on/under the CML because σ uses the full covariance (incl. market)._"
     ])
 
@@ -454,23 +439,20 @@ def compute_all(years_lookback: int, table: Optional[pd.DataFrame], use_embeddin
                 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()))
-
-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)
-    band = (which_band or "Medium").strip().title()
-    idx = max(1, min(3, int(pick_idx))) - 1
-    top3 = outs["top3_med"] if band=="Medium" else (outs["top3_low"] if band=="Low" else outs["top3_high"])
-
-    if top3.empty:
-        sugg_mu = None; sugg_sigma_hist = None; holdings = empty_holdings_df()
-    else:
-        row = top3.iloc[min(idx, len(top3)-1)]
+                best_low=best_low, best_med=best_med, best_high=best_high,
+                budget=gross)
+
+def render_with_band(years_lookback: int, table: Optional[pd.DataFrame], which_band: str):
+    outs = compute_all(years_lookback, table)
+    # pick which suggestion to highlight
+    row = outs["best_med"]
+    if (which_band or "").lower().startswith("low"): row = outs["best_low"]
+    if (which_band or "").lower().startswith("high"): row = outs["best_high"]
+
+    sugg_mu = None; sugg_sigma_hist = None; holdings = empty_holdings_df()
+    if isinstance(row, pd.Series) and not row.empty:
         sugg_mu = float(row["mu_capm"]); sugg_sigma_hist = float(row["sigma_hist"])
-        holdings = _pick_to_holdings(row, outs["budget"])
+        holdings = _row_to_holdings(row, outs["budget"])
 
     img = plot_cml_hybrid(
         outs["rf_ann"], outs["erp_ann"], outs["sigma_mkt"],
@@ -478,16 +460,26 @@ def compute_and_render(years_lookback: int, table: Optional[pd.DataFrame], use_e
         outs["mu_eff_same_sigma"], outs["sigma_eff_same_return"],
         sugg_mu, sugg_sigma_hist
     )
-    return (img, outs["info"], outs["uni_msg"], outs["pos_table"],
-            holdings, outs["csv_path"], outs["low_sum"], outs["med_sum"], outs["high_sum"])
+
+    # small stats for each band (single pick)
+    def _band_stats(s: pd.Series) -> str:
+        if s is None or s.empty: return "—"
+        return f"CAPM E[r] {float(s['mu_capm'])*100:.2f}%, σ(h) {float(s['sigma_hist'])*100:.2f}%"
+
+    low_stats = _band_stats(outs["best_low"])
+    med_stats = _band_stats(outs["best_med"])
+    high_stats = _band_stats(outs["best_high"])
+
+    return img, outs["info"], outs["uni_msg"], outs["pos_table"], holdings, outs["csv_path"], low_stats, med_stats, high_stats
 
 # -------------- UI --------------
 with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     gr.Markdown(
         "## Efficient Portfolio Advisor\n"
         "Plot uses **x = historical σ** and **y = CAPM E[r] = rf + β·ERP**. "
-        "Efficient (same σ) and (same E[r]) market/bills points are shown. "
-        "Suggestions come from 1,000 mixes; embeddings + MMR add diversity."
+        "Efficient (same σ) and (same E[r]) market/bills points are shown.\n\n"
+        "**Suggestions:** We re-weight the **same tickers you entered** to produce one Low/Medium/High pick. "
+        "Embeddings + exposure similarity select the best pick in each band."
     )
     with gr.Row():
         with gr.Column(scale=1):
@@ -499,18 +491,16 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
             table = gr.Dataframe(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")
-            use_emb = gr.Checkbox(value=True, label="Use finance embeddings + MMR for diverse picks")
-            gr.Markdown("### Suggestions")
-            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")
+
+            gr.Markdown("### Suggestions (one per band)")
+            with gr.Row():
+                low_btn  = gr.Button("Show Low")
+                med_btn  = gr.Button("Show Medium")
+                high_btn = gr.Button("Show High")
+            low_txt  = gr.Markdown("Low: —")
+            med_txt  = gr.Markdown("Medium: —")
+            high_txt = gr.Markdown("High: —")
+
             run_btn = gr.Button("Compute (build dataset & suggest)")
         with gr.Column(scale=1):
             plot = gr.Image(label="Capital Market Line (CAPM)", type="pil")
@@ -521,35 +511,40 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
                                           label="Selected suggestion holdings (% / $)")
             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])
     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)
 
+    # main compute (defaults to Medium highlighted)
     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]
+        fn=render_with_band,
+        inputs=[lookback, table, gr.State("Medium")],
+        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_txt, med_txt, high_txt]
     )
-    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]
+
+    # choose band with buttons
+    low_btn.click(
+        fn=render_with_band,
+        inputs=[lookback, table, gr.State("Low")],
+        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_txt, med_txt, high_txt]
     )
-    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]
+    med_btn.click(
+        fn=render_with_band,
+        inputs=[lookback, table, gr.State("Medium")],
+        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_txt, med_txt, high_txt]
     )
-    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]
+    high_btn.click(
+        fn=render_with_band,
+        inputs=[lookback, table, gr.State("High")],
+        outputs=[plot, summary, universe_msg, positions, selected_table, dl, low_txt, med_txt, high_txt]
     )
 
+# initialize risk-free at launch
 RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
 RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
 if __name__ == "__main__":
-    demo.queue()
+    demo.queue()  # no concurrency_count to keep compatibility with older Gradio
     demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT", 7860)), show_api=False, share=False)