Update app.py

app.py

@@ -1,5 +1,5 @@
-# app.py
-import os, io, math, json, time, random, warnings
+
+import os, io, math, json, warnings
 warnings.filterwarnings("ignore")
 
 from typing import List, Tuple, Dict, Optional
@@ -12,25 +12,57 @@ import requests
 import yfinance as yf
 import gradio as gr
 
-# Optional: finance embeddings for mild re-ranking of candidates
-try:
-    from sentence_transformers import SentenceTransformer
-    _EMB_MODEL = "FinLang/finance-embeddings-investopedia"
-    _emb = SentenceTransformer(_EMB_MODEL)
-except Exception:
-    _emb = None
+from sentence_transformers import SentenceTransformer
 
-# ---------------- config ----------------
+# ==============================
+# Config
+# ==============================
 DATA_DIR = "data"
-os.makedirs(DATA_DIR, exist_ok=True)
+DATASET_PATH = os.path.join(DATA_DIR, "investor_profiles.csv")
+
+MAX_TICKERS = 30
+DEFAULT_LOOKBACK_YEARS = 5
 
-DEFAULT_LOOKBACK_YEARS = 10
-MAX_TICKERS = 25
-MARKET_TICKER = "VOO"
+# Try these in order for "market"
+MARKET_CANDIDATES = ["VOO", "SPY", "IVV"]
 
+# Gradio table schemas
 POS_COLS = ["ticker", "amount_usd", "weight_exposure", "beta"]
-SUG_TABLE_COLS = ["ticker", "weight_%", "amount_$"]
+SUG_COLS = ["ticker", "weight_pct", "amount_usd"]
+
+# Globals (updated on events)
+HORIZON_YEARS = 5.0
+RF_CODE = "DGS5"
+RF_ANN = 0.03
+
+# Lazy-loaded embedding model
+_EMB_MODEL = None
+
+# ==============================
+# Small utils
+# ==============================
+def ensure_data_dir():
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+def fmt_pct(x: float) -> str:
+    try:
+        return f"{float(x)*100:.2f}%"
+    except Exception:
+        return "0.00%"
+
+def _pct(x):
+    """Return x in percent; accepts float or numpy array."""
+    return np.asarray(x, dtype=float) * 100.0
 
+def empty_positions_df():
+    return pd.DataFrame(columns=POS_COLS)
+
+def empty_suggest_df():
+    return pd.DataFrame(columns=SUG_COLS)
+
+# ==============================
+# Risk-free via FRED
+# ==============================
 FRED_MAP = [
     (1,  "DGS1"),
     (2,  "DGS2"),
@@ -43,16 +75,6 @@ FRED_MAP = [
     (100, "DGS30"),
 ]
 
-# ---------------- helpers ----------------
-def ensure_data_dir():
-    os.makedirs(DATA_DIR, exist_ok=True)
-
-def empty_positions_df():
-    return pd.DataFrame(columns=POS_COLS)
-
-def empty_suggest_df():
-    return pd.DataFrame(columns=SUG_TABLE_COLS)
-
 def fred_series_for_horizon(years: float) -> str:
     y = max(1.0, min(100.0, float(years)))
     for cutoff, code in FRED_MAP:
@@ -71,125 +93,94 @@ def fetch_fred_yield_annual(code: str) -> float:
     except Exception:
         return 0.03
 
-def _extract_close(df: pd.DataFrame, tickers: List[str]) -> pd.DataFrame:
-    """
-    Make yfinance output consistently a (date x tickers) DataFrame of Close prices.
-    Handles single/multi ticker and (Adj Close|Close) cases.
-    """
+# ==============================
+# Prices & returns (robust to yfinance shapes)
+# ==============================
+def _extract_close(df: pd.DataFrame) -> pd.DataFrame:
     if isinstance(df, pd.Series):
-        # Rare, but normalize
-        out = df.to_frame(name=tickers[0])
-        return out
-
+        return df.to_frame()
     if isinstance(df.columns, pd.MultiIndex):
-        lv0 = df.columns.get_level_values(0)
-        if "Close" in lv0:
-            px = df["Close"].copy()
-        elif "Adj Close" in lv0:
-            px = df["Adj Close"].copy()
-        else:
-            # Fallback to the first price-like level
-            first = next((x for x in ["Adj Close", "Close", "Close*"] if x in lv0), None)
-            if first is None:
-                first = lv0[0]
-            px = df[first].copy()
-        px.columns = [str(c) for c in px.columns]
-        return px
-
-    # Single ticker case with flat columns
-    candidates = [c for c in ["Close", "Adj Close"] if c in df.columns]
-    if candidates:
-        col = candidates[0]
-        return df[[col]].rename(columns={col: tickers[0]})
-
-    # Fallback: take first numeric column
-    first_num = [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
-    if first_num:
-        out = df[[first_num[0]]].copy()
-        out.columns = [tickers[0]]
-        return out
-
-    raise ValueError("Could not extract a price column")
+        for key in ["Close", "Adj Close"]:
+            try:
+                c = df.xs(key, axis=1, level=0)
+                return c
+            except Exception:
+                pass
+        # fallback: take first level
+        lvl0 = list(dict.fromkeys(df.columns.get_level_values(0)))
+        return df.xs(lvl0[0], axis=1, level=0)
+    else:
+        if "Close" in df.columns:
+            return df[["Close"]]
+        if "Adj Close" in df.columns:
+            c = df[["Adj Close"]].copy()
+            c.columns = ["Close"]
+            return c
+        return df
 
 def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
-    start = pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=years, days=7)
-    end = pd.Timestamp.today(tz="UTC")
+    tickers = list(dict.fromkeys([t for t in tickers if t]))  # unique, keep order
+    if not tickers:
+        return pd.DataFrame()
+    start = (pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=years, days=7)).date()
+    end = pd.Timestamp.today(tz="UTC").date()
     df = yf.download(
-        list(dict.fromkeys(tickers)),
-        start=start.date(),
-        end=end.date(),
+        tickers,
+        start=start,
+        end=end,
         interval="1mo",
         auto_adjust=True,
         progress=False,
-        group_by="column",
+        group_by="column"
     )
-    px = _extract_close(df, tickers)
-    px = px.dropna(how="all").ffill()
-    return px
+    if isinstance(df, pd.DataFrame):
+        df = _extract_close(df)
+    df = df.dropna(how="all").fillna(method="ffill")
+    # When single ticker, columns might be 1 col named by ticker or "Close"
+    if df.shape[1] == 1:
+        col = df.columns[0]
+        if col in ("Close", "Adj Close"):
+            # rename to ticker if only one requested
+            if len(tickers) == 1:
+                df.columns = [tickers[0]]
+    return df
 
 def monthly_returns(prices: pd.DataFrame) -> pd.DataFrame:
-    return prices.pct_change().dropna()
-
-def annualize_mean(m):
-    return np.asarray(m, dtype=float) * 12.0
-
-def annualize_sigma(s):
-    return np.asarray(s, dtype=float) * math.sqrt(12.0)
-
-def yahoo_search(query: str):
-    if not query or len(query.strip()) == 0:
-        return []
-    url = "https://query1.finance.yahoo.com/v1/finance/search"
-    params = {"q": query.strip(), "quotesCount": 10, "newsCount": 0}
-    headers = {"User-Agent": "Mozilla/5.0"}
-    try:
-        r = requests.get(url, params=params, headers=headers, timeout=10)
-        r.raise_for_status()
-        data = r.json()
-        out = []
-        for q in data.get("quotes", []):
-            sym = q.get("symbol")
-            name = q.get("shortname") or q.get("longname") or ""
-            exch = q.get("exchDisp") or ""
-            if sym and sym.isascii():
-                out.append({"symbol": sym, "name": name, "exchange": exch})
-        if not out:
-            out = [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "n a"}]
-        return out[:10]
-    except Exception:
-        return [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "n a"}]
-
-def validate_tickers(symbols: List[str], years: int) -> List[str]:
-    base = [s for s in dict.fromkeys(symbols) if s]
-    try:
-        px = fetch_prices_monthly(base + [MARKET_TICKER], years)
-    except Exception:
-        return []
-    ok = [s for s in base if s in px.columns]
-    return ok
-
-# -------------- aligned moments --------------
-def get_aligned_monthly_returns(symbols: List[str], years: int) -> pd.DataFrame:
-    uniq = [c for c in dict.fromkeys(symbols) if c != MARKET_TICKER]
-    tickers = uniq + [MARKET_TICKER]
-    px = fetch_prices_monthly(tickers, years)
+    return prices.pct_change().dropna(how="all")
+
+# ==============================
+# Aligned moments (market chosen dynamically)
+# ==============================
+def get_aligned_monthly_returns(symbols: List[str], years: int) -> Tuple[pd.DataFrame, str]:
+    uniq = [c for c in dict.fromkeys(symbols)]
+    want = list(dict.fromkeys(uniq + MARKET_CANDIDATES))
+    px = fetch_prices_monthly(want, years)
     rets = monthly_returns(px)
-    cols = [c for c in uniq if c in rets.columns] + ([MARKET_TICKER] if MARKET_TICKER in rets.columns else [])
+    # pick first available market
+    market = None
+    for m in MARKET_CANDIDATES:
+        if m in rets.columns:
+            market = m
+            break
+    if market is None:
+        raise ValueError("No market proxy (VOO/SPY/IVV) found in returned data.")
+    cols = [c for c in uniq if c in rets.columns] + [market]
     R = rets[cols].dropna(how="any")
-    return R.loc[:, ~R.columns.duplicated()]
+    R = R.loc[:, ~R.columns.duplicated()]
+    return R, market
 
 def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
-    R = get_aligned_monthly_returns(symbols + [MARKET_TICKER], years)
-    if MARKET_TICKER not in R.columns or R.shape[0] < 3:
-        raise ValueError("Not enough aligned returns (market missing or few rows).")
+    R, market = get_aligned_monthly_returns(symbols, years)
+    if market not in R.columns or R.shape[0] < 3:
+        raise ValueError("Not enough aligned data.")
     rf_m = rf_ann / 12.0
 
-    m = R[MARKET_TICKER]
+    m = R[market]
     if isinstance(m, pd.DataFrame):
         m = m.iloc[:, 0].squeeze()
 
-    mu_m_ann = float(annualize_mean(m.mean()))
-    sigma_m_ann = float(annualize_sigma(m.std(ddof=1)))
+    mu_m_ann = float(m.mean() * 12.0)
+    sigma_m_ann = float(m.std(ddof=1) * math.sqrt(12.0))
     erp_ann = float(mu_m_ann - rf_ann)
 
     ex_m = m - rf_m
@@ -197,21 +188,27 @@ def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
     var_m = max(var_m, 1e-8)
 
     betas: Dict[str, float] = {}
-    for s in [c for c in R.columns if c != MARKET_TICKER]:
+    for s in [c for c in R.columns if c != market]:
         ex_s = R[s] - rf_m
-        betas[s] = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1] / var_m)
-
-    betas[MARKET_TICKER] = 1.0  # by definition
-
-    asset_cols = [c for c in R.columns if c != MARKET_TICKER]
-    if asset_cols:
-        cov_m = np.cov(R[asset_cols].values.T, ddof=1)
-        covA = pd.DataFrame(cov_m * 12.0, index=asset_cols, columns=asset_cols)
-    else:
-        covA = pd.DataFrame([], index=[], columns=[])
-
-    return {"betas": betas, "cov_ann": covA, "erp_ann": erp_ann, "sigma_m_ann": sigma_m_ann}
-
+        b = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1] / var_m)
+        betas[s] = b
+    betas[market] = 1.0
+
+    asset_cols = [c for c in R.columns if c != market]
+    cov_m = np.cov(R[asset_cols].values.T, ddof=1) if asset_cols else np.zeros((0, 0))
+    covA = pd.DataFrame(cov_m * 12.0, index=asset_cols, columns=asset_cols)
+
+    return {
+        "betas": betas,
+        "cov_ann": covA,
+        "erp_ann": erp_ann,
+        "sigma_m_ann": sigma_m_ann,
+        "market": market,
+    }
+
+# ==============================
+# Portfolio stats (CAPM)
+# ==============================
 def capm_er(beta: float, rf_ann: float, erp_ann: float) -> float:
     return float(rf_ann + beta * erp_ann)
 
@@ -221,239 +218,184 @@ def portfolio_stats(weights: Dict[str, float],
                     rf_ann: float,
                     erp_ann: float) -> Tuple[float, float, float]:
     tickers = list(weights.keys())
+    if not tickers:
+        return 0.0, rf_ann, 0.0
     w = np.array([weights[t] for t in tickers], dtype=float)
     gross = float(np.sum(np.abs(w)))
     if gross == 0:
-        return 0.0, 0.0, 0.0
+        return 0.0, rf_ann, 0.0
     w_expo = w / gross
     beta_p = float(np.dot([betas.get(t, 0.0) for t in tickers], w_expo))
-    er_p = capm_er(beta_p, rf_ann, erp_ann)  # CAPM expected return
+    er_capm = capm_er(beta_p, rf_ann, erp_ann)
     cov = cov_ann.reindex(index=tickers, columns=tickers).fillna(0.0).to_numpy()
     sigma_p = math.sqrt(float(max(w_expo.T @ cov @ w_expo, 0.0)))
-    return beta_p, er_p, sigma_p
-
-# -------------- CML helpers --------------
-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
-
-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
-
-def _pct(x: float) -> float:
-    return float(x) * 100.0
-
-def plot_cml(
-    rf_ann, erp_ann, sigma_mkt,
-    pt_sigma, pt_mu,                  # <-- portfolio CAPM point
-    same_sigma_sigma, same_sigma_mu,
-    same_mu_sigma, same_mu_mu,
-    sugg_sigma=None, sugg_mu=None
-) -> Image.Image:
-    fig = plt.figure(figsize=(6.4, 4.2), dpi=140)
-
-    xmax = max(0.30, sigma_mkt * 2.0, pt_sigma * 1.4, same_mu_sigma * 1.4, same_sigma_sigma * 1.4, (sugg_sigma or 0.0) * 1.4)
-    xs = np.linspace(0, xmax, 200)
+    return beta_p, er_capm, sigma_p
+
+# ==============================
+# Plot CML with CAPM point
+# ==============================
+def plot_cml(rf_ann: float, erp_ann: float, sigma_mkt: float,
+             user_beta: float,
+             suggestion: Optional[Dict] = None) -> Image.Image:
+    fig = plt.figure(figsize=(6.4, 4.2), dpi=120)
     slope = erp_ann / max(sigma_mkt, 1e-12)
+    xmax = max(0.3, 2.0 * sigma_mkt)
+    xs = np.linspace(0.0, xmax, 180)
     cml = rf_ann + slope * xs
     plt.plot(_pct(xs), _pct(cml), label="CML via Market", linewidth=1.8)
 
-    # Key points
-    plt.scatter([0.0], [_pct(rf_ann)], label="Risk-free (FRED)")
-    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label=f"Market {MARKET_TICKER}")
-    plt.scatter([_pct(pt_sigma)], [_pct(pt_mu)], label="Your portfolio (CAPM)")
+    # Risk-free & market
+    plt.scatter([_pct(0.0)], [_pct(rf_ann)], label="Risk-free", s=25)
+    plt.scatter([_pct(sigma_mkt)], [_pct(rf_ann + erp_ann)], label="Market", s=25)
 
-    plt.scatter([_pct(same_sigma_sigma)], [_pct(same_sigma_mu)], label="Efficient same σ")
-    plt.scatter([_pct(same_mu_sigma)], [_pct(same_mu_mu)], label="Efficient same return")
-    if sugg_sigma is not None and sugg_mu is not None:
-        plt.scatter([_pct(sugg_sigma)], [_pct(sugg_mu)], label="Suggestion")
+    # User CAPM point projected onto CML using sigma = |beta| * sigma_mkt
+    sig_user = abs(user_beta) * sigma_mkt
+    mu_user = capm_er(user_beta, rf_ann, erp_ann)
+    plt.scatter([_pct(sig_user)], [_pct(mu_user)], label="Your CAPM point", s=35)
 
-    plt.xlabel("σ (annualized, %)")
+    # Optional suggestion point
+    if suggestion is not None:
+        plt.scatter([_pct(float(suggestion["sigma"]))],
+                    [_pct(float(suggestion["er"]))],
+                    label="Selected Suggestion", marker="D", s=35)
+
+    plt.xlabel("σ (annual, %)")
     plt.ylabel("Expected return (annual, %)")
     plt.legend(loc="best", fontsize=8)
     plt.tight_layout()
-
     buf = io.BytesIO()
     plt.savefig(buf, format="png")
     plt.close(fig)
     buf.seek(0)
     return Image.open(buf)
 
-# -------------- synthetic dataset for suggestions --------------
-def synth_profile(rng: np.random.Generator) -> str:
-    risk = rng.choice(["cautious", "balanced", "moderate", "growth", "aggressive"])
-    horizon = rng.choice(["three years", "five years", "seven years", "ten years", "fifteen years"])
-    goal = rng.choice(["retirement savings", "first home", "education fund", "wealth building", "travel fund", "emergency buffer"])
-    return f"{risk} investor, {horizon} horizon, goal is {goal}."
+# ==============================
+# Yahoo symbol search
+# ==============================
+def yahoo_search(query: str):
+    if not query or len(query.strip()) == 0:
+        return []
+    url = "https://query1.finance.yahoo.com/v1/finance/search"
+    params = {"q": query.strip(), "quotesCount": 10, "newsCount": 0}
+    headers = {"User-Agent": "Mozilla/5.0"}
+    try:
+        r = requests.get(url, params=params, headers=headers, timeout=10)
+        r.raise_for_status()
+        data = r.json()
+        out = []
+        for q in data.get("quotes", []):
+            sym = q.get("symbol")
+            name = q.get("shortname") or q.get("longname") or ""
+            exch = q.get("exchDisp") or ""
+            if sym and sym.isascii():
+                out.append({"symbol": sym, "name": name, "exchange": exch})
+        if not out:
+            out = [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "n/a"}]
+        return out[:10]
+    except Exception:
+        return [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "n/a"}]
 
-def build_synthetic_dataset(universe: List[str], years: int, rf_ann: float, erp_ann: float, covA: pd.DataFrame, betas: Dict[str, float]) -> pd.DataFrame:
-    # build 1,000 random portfolios over the user universe (CAPM ER, cov-based sigma)
-    rng = np.random.default_rng(42 + int(time.time()) % 10000)
-    rows = []
-    for i in range(1000):
-        k = rng.integers(low=min(2, len(universe)), high=min(8, len(universe)) + 1)
-        picks = list(rng.choice(universe, size=k, replace=False))
-        signs = rng.choice([-1.0, 1.0], size=k, p=[0.25, 0.75])
-        raw = rng.dirichlet(np.ones(k))
-        gross = 1.0 + float(rng.gamma(2.0, 0.5))
-        w = gross * signs * raw  # exposure weights that sum (in abs) to gross
+def validate_tickers(symbols: List[str], years: int) -> List[str]:
+    base = list(dict.fromkeys([s for s in symbols if s]))
+    px = fetch_prices_monthly(base + MARKET_CANDIDATES, years)
+    ok = [s for s in base if s in px.columns]
+    return ok
 
-        wmap = {picks[j]: float(w[j]) for j in range(k)}
-        beta_p, er_p, sigma_p = portfolio_stats(wmap, covA, betas, rf_ann, erp_ann)
+# ==============================
+# Synthetic dataset & suggestions
+# ==============================
+def synth_profile_text(beta: float, sigma: float, er: float, weights: Dict[str, float]) -> str:
+    top = sorted(weights.items(), key=lambda kv: -abs(kv[1]))[:8]
+    parts = [f"{k} {abs(v)*100:.1f}%" for k, v in top]
+    return (
+        f"portfolio with beta {beta:.2f}, volatility {sigma:.3f}, expected return {er:.3f}; "
+        f"holdings: " + ", ".join(parts)
+    )
 
+def build_synthetic_dataset(universe: List[str],
+                            rf_ann: float,
+                            erp_ann: float,
+                            betas: Dict[str, float],
+                            covA: pd.DataFrame,
+                            n_rows: int = 1000,
+                            seed: int = 123) -> pd.DataFrame:
+    rng = np.random.default_rng(seed)
+    rows = []
+    assets = [t for t in universe]  # long-only samples
+    for i in range(n_rows):
+        k = rng.integers(low=max(2, min(2, len(assets))), high=max(3, min(8, len(assets))) + 1)
+        picks = list(rng.choice(assets, size=min(k, len(assets)), replace=False))
+        raw = rng.dirichlet(np.ones(len(picks)))
+        wmap = {picks[j]: float(raw[j]) for j in range(len(picks))}
+        beta_p, er_capm, sigma_p = portfolio_stats(wmap, covA, betas, rf_ann, erp_ann)
         rows.append({
-            "id": i,
-            "profile_text": synth_profile(rng),
             "tickers": ",".join(picks),
-            "weights": ",".join(f"{x:.6f}" for x in w),
-            "beta_p": beta_p,
-            "er_p": er_p,
-            "sigma_p": sigma_p
+            "weights": ",".join(f"{wmap[t]:.6f}" for t in picks),
+            "beta": beta_p,
+            "er": er_capm,
+            "sigma": sigma_p,
+            "desc": synth_profile_text(beta_p, sigma_p, er_capm, wmap),
         })
-    return pd.DataFrame(rows)
-
-def _row_to_exposures(row: pd.Series, universe: List[str]) -> Optional[np.ndarray]:
-    try:
-        ts = [t.strip() for t in str(row["tickers"]).split(",")]
-        ws = [float(x) for x in str(row["weights"]).split(",")]
-        wmap = {t: ws[i] for i, t in enumerate(ts) if i < len(ws)}
-        w = np.array([wmap.get(t, 0.0) for t in universe], dtype=float)
-        gross = float(np.sum(np.abs(w)))
-        if gross <= 1e-12:
-            return None
-        return w / gross
-    except Exception:
-        return None
-
-def _risk_query_text(risk: str) -> str:
-    if risk == "Low":
-        return "conservative low-volatility long-term capital preservation diversified investment grade"
-    if risk == "High":
-        return "aggressive high risk high growth momentum speculative tech heavy"
-    return "balanced moderate risk growth and income diversified core equities and bonds"
-
-def _embed_scores(texts: List[str], query: str) -> np.ndarray:
-    if _emb is None:
-        return np.zeros(len(texts), dtype=float)
-    qv = _emb.encode([query], normalize_embeddings=True)[0]
-    M = _emb.encode(texts, normalize_embeddings=True)
-    sims = (M @ qv).astype(float)
-    return sims
-
-def make_suggestions(csv_path: str,
-                     universe: List[str],
-                     risk: str,
-                     use_embeddings: bool) -> List[Dict]:
-    """
-    Return a list of 3 suggestions. Each item:
-      {"weights": {ticker: expo}, "er": float, "sigma": float, "beta": float, "row_text": str}
-    """
-    try:
-        df = pd.read_csv(csv_path)
-    except Exception:
-        return []
+    df = pd.DataFrame(rows)
+    return df
 
-    # Keep only rows that map nicely to current universe
-    rows = []
-    exps = []
-    for _, r in df.iterrows():
-        x = _row_to_exposures(r, universe)
-        if x is None:
-            continue
-        rows.append(r)
-        exps.append(x)
-    if not rows:
+def get_embedding_model():
+    global _EMB_MODEL
+    if _EMB_MODEL is None:
+        _EMB_MODEL = SentenceTransformer("FinLang/finance-embeddings-investopedia")
+    return _EMB_MODEL
+
+def encode_texts(texts: List[str]):
+    model = get_embedding_model()
+    return model.encode(texts, normalize_embeddings=True)
+
+def cosine_sim(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    return (a @ b.T)
+
+def select_bucket_candidates(df: pd.DataFrame, bucket: str) -> pd.DataFrame:
+    # bucket by sigma tertiles
+    q1 = df["sigma"].quantile(1/3)
+    q2 = df["sigma"].quantile(2/3)
+    if bucket == "Low":
+        return df[df["sigma"] <= q1]
+    if bucket == "Medium":
+        return df[(df["sigma"] > q1) & (df["sigma"] <= q2)]
+    return df[df["sigma"] > q2]
+
+def parse_weights(row: pd.Series) -> Dict[str, float]:
+    ts = [t.strip() for t in str(row["tickers"]).split(",")]
+    ws = [float(x) for x in str(row["weights"]).split(",")]
+    wmap = {ts[i]: ws[i] for i in range(min(len(ts), len(ws)))}
+    # normalize just in case
+    s = sum(abs(v) for v in wmap.values()) or 1.0
+    return {k: v / s for k, v in wmap.items()}
+
+def pick_top3_for_bucket(df: pd.DataFrame, bucket: str) -> List[Dict]:
+    cand = select_bucket_candidates(df, bucket)
+    if cand.empty:
         return []
-
-    exps = np.vstack(exps)
-    sigs = np.array([float(r["sigma_p"]) for r in rows])
-    ers = np.array([float(r["er_p"]) for r in rows])
-
-    # Choose a target sigma by risk quantile
-    qmap = {"Low": 0.25, "Medium": 0.50, "High": 0.85}
-    q = qmap.get(risk, 0.50)
-    target_sigma = float(np.quantile(sigs, q=q))
-
-    # Rank by closeness in sigma to target
-    base_idx = np.argsort(np.abs(sigs - target_sigma))
-
-    # Optional: light re-ranking using embeddings to prefer text that matches risk intent
-    if use_embeddings:
-        texts = [str(rows[i]["profile_text"]) for i in base_idx[:120]]
-        sims = _embed_scores(texts, _risk_query_text(risk))
-        # Blend: 80% sigma closeness (smaller better) and -20% similarity (larger better)
-        closeness = np.abs(sigs[base_idx[:120]] - target_sigma)
-        score = 0.8 * (closeness / (closeness.max() + 1e-9)) - 0.2 * sims
-        rerank_local = np.argsort(score)
-        idx = base_idx[:120][rerank_local]
-    else:
-        idx = base_idx
-
-    # Take top 3 diverse by exposure distance
-    picks, chosen = [], []
-    for i in idx:
-        wvec = exps[i]
-        # enforce some diversity
-        ok = True
-        for j in chosen:
-            if np.linalg.norm(wvec - exps[j]) < 0.25:
-                ok = False
-                break
-        if not ok:
-            continue
-        chosen.append(i)
-        r = rows[i]
-        wmap = {universe[k]: float(wvec[k]) for k in range(len(universe)) if abs(wvec[k]) > 1e-4}
-        picks.append({
-            "weights": wmap,
-            "er": float(r["er_p"]),
-            "sigma": float(r["sigma_p"]),
-            "beta": float(r["beta_p"]),
-            "row_text": str(r["profile_text"])
-        })
-        if len(picks) == 3:
-            break
+    # Rank by embedding similarity to a short query
+    query_map = {
+        "Low": "low risk, stable portfolio, conservative volatility",
+        "Medium": "balanced risk portfolio, moderate volatility",
+        "High": "high risk, growth portfolio, higher volatility"
+    }
+    q = query_map[bucket]
+    embs_cand = encode_texts(cand["desc"].tolist())
+    emb_q = encode_texts([q])[0].reshape(1, -1)
+    sims = cosine_sim(emb_q, embs_cand).flatten()
+    order = np.argsort(-sims)
+    picks = []
+    for idx in order[:3]:
+        r = cand.iloc[int(idx)]
+        wmap = parse_weights(r)
+        picks.append({"weights": wmap, "beta": float(r["beta"]),
+                      "er": float(r["er"]), "sigma": float(r["sigma"])})
     return picks
 
-# -------------- formatting helpers --------------
-def fmt_pct(x: float, dp: int = 2) -> str:
-    return f"{x*100:.{dp}f}%"
-
-def build_summary_md(lookback, horizon, rf, rf_code, erp, sigma_mkt,
-                     beta_p, sigma_hist, mu_hist, mu_capm,
-                     a_sigma, b_sigma, mu_eff_sigma,
-                     a_mu, b_mu, sigma_eff_mu) -> str:
-    lines = []
-    lines.append("### Inputs")
-    lines.append(f"- Lookback years **{lookback}**")
-    lines.append(f"- Horizon years **{horizon}**")
-    lines.append(f"- Risk-free **{fmt_pct(rf)}** from **{rf_code}**")
-    lines.append(f"- Market ERP **{fmt_pct(erp)}**")
-    lines.append(f"- Market σ **{fmt_pct(sigma_mkt)}**")
-    lines.append("")
-    lines.append("### Your portfolio (CAPM expectations)")
-    lines.append(f"- Beta **{beta_p:.2f}**")
-    lines.append(f"- σ (historical) **{fmt_pct(sigma_hist)}**")
-    lines.append(f"- Expected return (historical) **{fmt_pct(mu_hist)}**")
-    lines.append(f"- Expected return (CAPM / SML) **{fmt_pct(mu_capm)}**")
-    lines.append("")
-    lines.append("### Efficient alternatives on CML")
-    lines.append(f"- Same σ as your portfolio → Market weight **{a_sigma:.2f}**, Bills weight **{b_sigma:.2f}**, return **{fmt_pct(mu_eff_sigma)}**")
-    lines.append(f"- Same return (CAPM) → Market weight **{a_mu:.2f}**, Bills weight **{b_mu:.2f}**, σ **{fmt_pct(sigma_eff_mu)}**")
-    return "\n".join(lines)
-
-# -------------- stateful globals on launch --------------
-ensure_data_dir()
-HORIZON_YEARS = 10
-RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
-RF_ANN = fetch_fred_yield_annual(RF_CODE)
-
-# -------------- gradio callbacks --------------
+# ==============================
+# Gradio callbacks
+# ==============================
 def search_tickers_cb(q: str):
     hits = yahoo_search(q)
     if not hits:
@@ -463,12 +405,10 @@ def search_tickers_cb(q: str):
 
 def add_symbol(selection: str, table: pd.DataFrame):
     if not selection:
-        return table, "Pick a row from Matches first"
+        return table, "Pick a row from Matches first", gr.update(value=None)
     symbol = selection.split("|")[0].strip().upper()
     current = [] if table is None or len(table) == 0 else [str(x).upper() for x in table["ticker"].tolist() if str(x) != "nan"]
     tickers = current if symbol in current else current + [symbol]
-
-    # validate against yfinance (with market ticker alongside to force download structure)
     val = validate_tickers(tickers, years=DEFAULT_LOOKBACK_YEARS)
     tickers = [t for t in tickers if t in val]
     amt_map = {}
@@ -482,7 +422,7 @@ def add_symbol(selection: str, table: pd.DataFrame):
     if len(new_table) > MAX_TICKERS:
         new_table = new_table.iloc[:MAX_TICKERS]
         msg = f"Reached max of {MAX_TICKERS}"
-    return new_table, msg
+    return new_table, msg, gr.update(value=None)  # also clears dropdown
 
 def lock_ticker_column(tb: pd.DataFrame):
     if tb is None or len(tb) == 0:
@@ -499,197 +439,187 @@ def set_horizon(years: float):
     code = fred_series_for_horizon(y)
     rf = fetch_fred_yield_annual(code)
     global HORIZON_YEARS, RF_CODE, RF_ANN
-    HORIZON_YEARS = int(round(y))
+    HORIZON_YEARS = y
     RF_CODE = code
     RF_ANN = rf
-    return f"Risk free series {code}. Latest annual rate {rf:.2%}. Using this for CAPM."
-
-def _build_dataset_path() -> str:
-    return os.path.join(DATA_DIR, f"investor_profiles_{hex(random.getrandbits(32))[2:]}.csv")
-
-def compute(
-    years_lookback: int,
-    table: pd.DataFrame,
-    risk_choice: str,
-    use_embeddings: bool
-):
-    # --- sanitize input table ---
+    return f"Risk-free series {code}. Latest annual rate {rf:.2%}."
+
+def build_summary_md(lookback, rf_code, rf, erp, sigma_mkt,
+                     beta_p, er_capm, sigma_cml_user,
+                     market_sym) -> str:
+    lines = []
+    lines.append("### Inputs")
+    lines.append(f"- Lookback years {lookback}")
+    lines.append(f"- Horizon years {int(round(HORIZON_YEARS))}")
+    lines.append(f"- Risk-free {fmt_pct(rf)} from {rf_code}")
+    lines.append(f"- Market ERP {fmt_pct(erp)}")
+    lines.append(f"- Market σ {fmt_pct(sigma_mkt)} (proxy: {market_sym})")
+    lines.append("")
+    lines.append("### Your portfolio (CAPM)")
+    lines.append(f"- Beta {beta_p:.2f}")
+    lines.append(f"- Expected return (CAPM / SML) {fmt_pct(er_capm)}")
+    lines.append(f"- σ on CML for your beta (|β|×σ_mkt) {fmt_pct(sigma_cml_user)}")
+    return "\n".join(lines)
+
+def pack_suggestion_table(pick: Dict, gross_usd: float) -> pd.DataFrame:
+    rows = []
+    for t, w in sorted(pick["weights"].items(), key=lambda kv: -kv[1]):
+        rows.append({
+            "ticker": t,
+            "weight_pct": float(w) * 100.0,
+            "amount_usd": float(w) * float(gross_usd)
+        })
+    return pd.DataFrame(rows, columns=SUG_COLS)
+
+def suggestion_metrics_md(pick: Dict) -> str:
+    return (
+        f"**Suggested portfolio**  \n"
+        f"- Expected return (CAPM) {fmt_pct(pick['er'])}  \n"
+        f"- σ (annual) {fmt_pct(pick['sigma'])}  \n"
+        f"- Beta {pick['beta']:.2f}"
+    )
+
+def compute(years_lookback: int,
+            table: pd.DataFrame,
+            risk_choice: str,
+            pick_choice: str):
+    # ---------- sanitize input table ----------
     if table is None or len(table) == 0:
-        return None, "Add at least one ticker", "Universe empty", empty_positions_df(), gr.update(choices=[], value=None), empty_suggest_df(), None, {}
+        return None, "Add at least one ticker.", "Universe empty", empty_positions_df(), {}, gr.update(), gr.update(), "", empty_suggest_df()
 
     df = table.dropna()
     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:
-        return None, "Add at least one ticker", "Universe empty", empty_positions_df(), gr.update(choices=[], value=None), empty_suggest_df(), None, {}
 
     symbols = validate_tickers(symbols, years_lookback)
     if len(symbols) == 0:
-        return None, "Could not validate any tickers", "Universe invalid", empty_positions_df(), gr.update(choices=[], value=None), empty_suggest_df(), None, {}
-
-    universe = list(sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER])))[:MAX_TICKERS]
+        return None, "Could not validate any tickers.", "Universe invalid", empty_positions_df(), {}, gr.update(), gr.update(), "", empty_suggest_df()
 
-    df = df[df["ticker"].isin(symbols)].copy()
-    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
+    # ---------- amounts & weights ----------
+    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows() if r["ticker"] in symbols}
     gross = sum(abs(v) for v in amounts.values())
-    if gross <= 1e-12:
-        return None, "All amounts are zero", "Universe ok", empty_positions_df(), gr.update(choices=[], value=None), empty_suggest_df(), None, {}
+    if gross == 0:
+        return None, "All amounts are zero.", "Universe ok", empty_positions_df(), {}, gr.update(), gr.update(), "", empty_suggest_df()
+    weights_user = {k: v / gross for k, v in amounts.items()}
 
-    # --- CAPM ingredients ---
+    # ---------- risk-free & moments ----------
     rf_ann = RF_ANN
     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"]
+    betas, covA = moms["betas"], moms["cov_ann"]
+    erp_ann, sigma_mkt, market_sym = moms["erp_ann"], moms["sigma_m_ann"], moms["market"]
 
-    # portfolio weights/exposures
-    weights = {k: v / gross for k, v in amounts.items()}
-    beta_p, mu_capm, sigma_p = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
+    # ---------- user stats (CAPM) ----------
+    beta_p, er_capm, _sigma_hist = portfolio_stats(weights_user, covA, betas, rf_ann, erp_ann)
+    sigma_user_on_cml = abs(beta_p) * sigma_mkt  # plotted, ensures point on CML
 
-    # historical mean (for info only)
-    try:
-        R = get_aligned_monthly_returns(symbols, years_lookback)
-        mu_hist = float(annualize_mean(R[symbols].mean().dot(np.array([weights[s] for s in symbols]))))
-        sigma_hist = sigma_p  # same sigma as built from covA
-    except Exception:
-        mu_hist = mu_capm
-        sigma_hist = sigma_p
-
-    # efficient points on CML (use CAPM target)
-    a_sigma, b_sigma, mu_eff_sigma = efficient_same_sigma(sigma_p, rf_ann, erp_ann, sigma_mkt)
-    a_mu, b_mu, sigma_eff_mu = efficient_same_return(mu_capm, rf_ann, erp_ann, sigma_mkt)
-
-    # --- Build dataset once for this run (universe-specific) ---
-    ds_path = _build_dataset_path()
-    synth_df = build_synthetic_dataset(
-        universe=[u for u in universe if u != MARKET_TICKER],
-        years=years_lookback,
-        rf_ann=rf_ann,
-        erp_ann=erp_ann,
-        covA=covA,
-        betas=betas
-    )
-    synth_df.to_csv(ds_path, index=False)
-
-    # --- Suggestions (3 picks) ---
-    picks = make_suggestions(ds_path, [u for u in universe if u != MARKET_TICKER], risk_choice, use_embeddings)
-    if not picks:
-        pick_choices = []
-        sugg_table = empty_suggest_df()
-        sugg_sigma = None
-        sugg_mu = None
-    else:
-        pick_choices = [f"Pick #{i+1}" for i in range(len(picks))]
-        # default selection = first pick
-        first = picks[0]
-        sugg_sigma = float(first["sigma"])
-        sugg_mu = float(first["er"])
-        sugg_table = _pick_table(first, amounts)
-
-    # --- Plot with CAPM portfolio and suggestion point (if any) ---
-    img = plot_cml(
-        rf_ann, erp_ann, sigma_mkt,
-        pt_sigma=sigma_p, pt_mu=mu_capm,
-        same_sigma_sigma=sigma_p, same_sigma_mu=mu_eff_sigma,
-        same_mu_sigma=sigma_eff_mu, same_mu_mu=mu_capm,
-        sugg_sigma=sugg_sigma, sugg_mu=sugg_mu
-    )
-
-    # --- Summary text ---
-    summary = build_summary_md(
-        years_lookback, HORIZON_YEARS, rf_ann, RF_CODE, erp_ann, sigma_mkt,
-        beta_p, sigma_hist, mu_hist, mu_capm,
-        a_sigma, b_sigma, mu_eff_sigma,
-        a_mu, b_mu, sigma_eff_mu
-    )
-
-    # positions table
+    # ---------- positions table ----------
     rows = []
     for t in symbols:
-        beta_val = 1.0 if t == MARKET_TICKER else betas.get(t, np.nan)
         rows.append({
             "ticker": t,
             "amount_usd": amounts.get(t, 0.0),
-            "weight_exposure": weights.get(t, 0.0),
-            "beta": beta_val,
+            "weight_exposure": weights_user.get(t, 0.0),
+            "beta": 1.0 if abs(betas.get(t, 0.0) - 1.0) < 1e-9 else betas.get(t, np.nan)
         })
     pos_table = pd.DataFrame(rows, columns=POS_COLS)
 
-    uni_msg = f"Universe set to {', '.join(universe)}"
-    # Return suggestions state so the picker can swap views
-    suggestions_state = {"picks": picks, "amounts": amounts, "rf": rf_ann, "erp": erp_ann, "sigma_mkt": sigma_mkt, "mu_capm": mu_capm, "sigma_p": sigma_p}
-    return img, summary, uni_msg, pos_table, gr.update(choices=pick_choices, value=(pick_choices[0] if pick_choices else None), interactive=bool(pick_choices)), sugg_table, ds_path, suggestions_state
-
-def _pick_table(pick: Dict, amounts_map: Dict[str, float]) -> pd.DataFrame:
-    gross = float(sum(abs(v) for v in amounts_map.values()))
-    wmap = pick["weights"]
-    # normalize to exposures sum of abs = 1 for display
-    gross_w = sum(abs(v) for v in wmap.values())
-    if gross_w <= 1e-12:
-        return empty_suggest_df()
-    w_norm = {k: v / gross_w for k, v in wmap.items()}
-    rows = []
-    for t, w in sorted(w_norm.items(), key=lambda kv: -abs(kv[1])):
-        rows.append({
-            "ticker": t,
-            "weight_%": 100.0 * float(w),
-            "amount_$": float(w) * gross
-        })
-    df = pd.DataFrame(rows, columns=SUG_TABLE_COLS)
-    return df
-
-def on_select_pick(choice: Optional[str], suggestions_state: Dict):
-    if not choice or not suggestions_state or not suggestions_state.get("picks"):
-        return empty_suggest_df(), gr.update(value=None)
-    idx = int(choice.split("#")[1]) - 1
-    idx = max(0, min(idx, len(suggestions_state["picks"]) - 1))
-    pick = suggestions_state["picks"][idx]
-    table = _pick_table(pick, suggestions_state["amounts"])
-
-    # Update the plot with the chosen suggestion dot
-    img = plot_cml(
-        suggestions_state["rf"],
-        suggestions_state["erp"],
-        suggestions_state["sigma_mkt"],
-        pt_sigma=suggestions_state["sigma_p"],
-        pt_mu=suggestions_state["mu_capm"],
-        same_sigma_sigma=suggestions_state["sigma_p"],
-        same_sigma_mu=efficient_same_sigma(suggestions_state["sigma_p"], suggestions_state["rf"], suggestions_state["erp"], suggestions_state["sigma_mkt"])[2],
-        same_mu_sigma=efficient_same_return(suggestions_state["mu_capm"], suggestions_state["rf"], suggestions_state["erp"], suggestions_state["sigma_mkt"])[2],
-        same_mu_mu=suggestions_state["mu_capm"],
-        sugg_sigma=float(pick["sigma"]),
-        sugg_mu=float(pick["er"]),
+    # ---------- synthetic dataset ----------
+    ensure_data_dir()
+    synth_df = build_synthetic_dataset(
+        universe=list(sorted(set(symbols))),
+        rf_ann=rf_ann,
+        erp_ann=erp_ann,
+        betas=betas,
+        covA=covA,
+        n_rows=1000,
+        seed=123
+    )
+    try:
+        synth_df.to_csv(DATASET_PATH, index=False)
+    except Exception:
+        pass
+
+    # ---------- pick 3 per bucket using embeddings ----------
+    low3 = pick_top3_for_bucket(synth_df, "Low")
+    med3 = pick_top3_for_bucket(synth_df, "Medium")
+    high3 = pick_top3_for_bucket(synth_df, "High")
+
+    # ---------- build state ----------
+    state = {
+        "gross": float(gross),
+        "picks": {"Low": low3, "Medium": med3, "High": high3},
+        "rf": float(rf_ann),
+        "erp": float(erp_ann),
+        "sigma_mkt": float(sigma_mkt),
+        "user_beta": float(beta_p)
+    }
+
+    # ---------- decide which suggestion to show initially ----------
+    risk = risk_choice if risk_choice in ("Low", "Medium", "High") else "Medium"
+    pick_idx = 0 if pick_choice not in ("Pick #1", "Pick #2", "Pick #3") else ["Pick #1", "Pick #2", "Pick #3"].index(pick_choice)
+    picks_list = state["picks"].get(risk, [])
+    pick = picks_list[pick_idx] if pick_idx < len(picks_list) else (picks_list[0] if picks_list else None)
+
+    # ---------- plot ----------
+    img = plot_cml(rf_ann, erp_ann, sigma_mkt, beta_p, suggestion=pick)
+
+    # ---------- summary ----------
+    info = build_summary_md(
+        years_lookback, RF_CODE, rf_ann, erp_ann, sigma_mkt,
+        beta_p, er_capm, sigma_user_on_cml, market_sym
     )
-    return table, img
 
-# -------------- UI --------------
-with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
-    with gr.Accordion("About (assignment section 1)", open=False):
-        gr.Markdown(
-            "**Modality:** Text\n\n"
-            "**Model:** FinLang/finance-embeddings-investopedia (optional, for mild re-ranking of dataset suggestions).\n\n"
-            "**Use case:** User enters tickers and dollar amounts; the app computes CAPM expectations and shows the "
-            "Capital Market Line. From a synthetic dataset (1,000 portfolios generated over the user’s universe), "
-            "the system returns 3 similar portfolios (Low/Medium/High risk picks). The user can flip between the "
-            "suggested picks and see holdings in % and $ plus where the suggestion sits on the CML.\n"
-        )
+    # ---------- suggestion UI ----------
+    risk_update = gr.update(choices=["Low", "Medium", "High"], value=risk)
+    pick_update = gr.update(choices=["Pick #1", "Pick #2", "Pick #3"], value="Pick #1")
+
+    if pick is None:
+        return img, info, f"Universe set to {', '.join(sorted(symbols))}", pos_table, state, risk_update, pick_update, "No suggestions available.", empty_suggest_df()
+
+    sug_md = suggestion_metrics_md(pick)
+    sug_table = pack_suggestion_table(pick, gross)
+
+    return img, info, f"Universe set to {', '.join(sorted(symbols))}", pos_table, state, risk_update, pick_update, sug_md, sug_table
+
+def update_suggestion(risk: str, pick_name: str, state: dict):
+    if not state or "picks" not in state:
+        return gr.update(), "", empty_suggest_df()
+    picks_list = state["picks"].get(risk, [])
+    if not picks_list:
+        return gr.update(), "No suggestions for this bucket.", empty_suggest_df()
+    idx = ["Pick #1", "Pick #2", "Pick #3"].index(pick_name) if pick_name in ("Pick #1", "Pick #2", "Pick #3") else 0
+    idx = min(idx, len(picks_list) - 1)
+    pick = picks_list[idx]
+    img = plot_cml(state["rf"], state["erp"], state["sigma_mkt"], state["user_beta"], suggestion=pick)
+    sug_md = suggestion_metrics_md(pick)
+    sug_table = pack_suggestion_table(pick, state.get("gross", 0.0))
+    return img, sug_md, sug_table
+
+# ==============================
+# Build UI
+# ==============================
+ensure_data_dir()
+RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
+RF_ANN = fetch_fred_yield_annual(RF_CODE)
 
+with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     gr.Markdown(
         "## Efficient Portfolio Advisor\n"
-        "Search symbols, enter dollar amounts, set your horizon. Prices from Yahoo Finance. Risk-free from FRED. "
-        "Low/Medium/High suggestions are chosen only from a 1,000-row dataset generated from your current universe, "
-        "optionally refined with finance embeddings."
+        "Search symbols, enter **dollar amounts**, set horizon. "
+        "Returns are from Yahoo Finance (monthly). Risk-free is from FRED. "
+        "Plot shows **CAPM point on the CML** (no historical returns plotted)."
     )
 
     with gr.Row():
         with gr.Column(scale=1):
             q = gr.Textbox(label="Search symbol")
             search_note = gr.Markdown()
-            matches = gr.Dropdown(choices=[], label="Matches")
-            with gr.Row():
-                search_btn = gr.Button("Search")
-                add_btn = gr.Button("Add selected to portfolio")
+            matches = gr.Dropdown(choices=[], label="Matches", allow_custom_value=True)
+            search_btn = gr.Button("Search")
+            add_btn = gr.Button("Add selected to portfolio")
 
-            gr.Markdown("### Portfolio positions — type dollar amounts (negatives allowed for shorts)")
+            gr.Markdown("### Portfolio positions (enter $ amounts; negatives allowed for shorts)")
             table = gr.Dataframe(
                 headers=["ticker", "amount_usd"],
                 datatype=["str", "number"],
@@ -698,17 +628,13 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
             )
 
             horizon = gr.Number(label="Horizon in years (1–100)", value=HORIZON_YEARS, precision=0)
-            lookback = gr.Slider(1, 10, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for beta & sigma")
-
-            gr.Markdown("### Suggestions")
-            risk = gr.Radio(["Low", "Medium", "High"], value="Medium", label="Risk tolerance")
-            use_emb = gr.Checkbox(label="Use finance embeddings to refine picks", value=True)
+            lookback = gr.Slider(1, 10, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for betas & covariances")
 
-            run_btn = gr.Button("Compute (build dataset & suggest)", variant="primary")
+            run_btn = gr.Button("Compute")
 
         with gr.Column(scale=1):
-            plot = gr.Image(label="Capital Market Line (CML)", type="pil")
-            summary = gr.Markdown(label="Inputs & CAPM expectations")
+            plot = gr.Image(label="Capital Market Line (CAPM)", type="pil")
+            summary = gr.Markdown(label="Summary")
             universe_msg = gr.Textbox(label="Universe status", interactive=False)
 
             positions = gr.Dataframe(
@@ -720,43 +646,47 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
                 interactive=False
             )
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            pick_select = gr.Radio(choices=[], label="Suggested pick (flip between #1 / #2 / #3)", interactive=False)
-        with gr.Column(scale=1):
-            sugg_table = gr.Dataframe(
-                label="Suggestion holdings — % and $",
-                headers=SUG_TABLE_COLS,
+            gr.Markdown("### Dataset-based suggestions (choose risk bucket and pick)")
+            state = gr.State({})
+            risk_selector = gr.Radio(choices=["Low", "Medium", "High"], value="Medium", label="Risk bucket to view")
+            pick_selector = gr.Radio(choices=["Pick #1", "Pick #2", "Pick #3"], value="Pick #1", label="Suggestion")
+            sugg_metrics = gr.Markdown(label="Suggestion metrics")
+            suggestions = gr.Dataframe(
+                label="Suggested holdings",
+                headers=SUG_COLS,
                 datatype=["str", "number", "number"],
-                col_count=(len(SUG_TABLE_COLS), "fixed"),
+                col_count=(len(SUG_COLS), "fixed"),
                 value=empty_suggest_df(),
                 interactive=False
             )
-    dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
 
-    # hidden state for suggestions
-    suggestions_state = gr.State({})
-
-    # wire events
+    # --- wiring ---
     def do_search(query):
         note, options = search_tickers_cb(query)
-        return note, gr.update(choices=options)
+        # Clear previous selection to avoid “not in choices”
+        return note, gr.update(choices=options, value=None)
 
     search_btn.click(fn=do_search, inputs=q, outputs=[search_note, matches])
-    add_btn.click(fn=add_symbol, inputs=[matches, table], outputs=[table, search_note])
+    add_btn.click(fn=add_symbol, inputs=[matches, table], outputs=[table, search_note, matches])
     table.change(fn=lock_ticker_column, inputs=table, outputs=table)
     horizon.change(fn=set_horizon, inputs=horizon, outputs=universe_msg)
 
     run_btn.click(
         fn=compute,
-        inputs=[lookback, table, risk, use_emb],
-        outputs=[plot, summary, universe_msg, positions, pick_select, sugg_table, dl, suggestions_state]
+        inputs=[lookback, table, risk_selector, pick_selector],
+        outputs=[plot, summary, universe_msg, positions, state, risk_selector, pick_selector, sugg_metrics, suggestions]
     )
 
-    pick_select.change(
-        fn=on_select_pick,
-        inputs=[pick_select, suggestions_state],
-        outputs=[sugg_table, plot]
+    # Update suggestion view without recomputing moments
+    risk_selector.change(
+        fn=update_suggestion,
+        inputs=[risk_selector, pick_selector, state],
+        outputs=[plot, sugg_metrics, suggestions]
+    )
+    pick_selector.change(
+        fn=update_suggestion,
+        inputs=[risk_selector, pick_selector, state],
+        outputs=[plot, sugg_metrics, suggestions]
     )
 
 if __name__ == "__main__":