Update app.py

app.py

@@ -1,7 +1,5 @@
-import os
-import io
-import math
-import warnings
+# app.py
+import os, io, math, json, hashlib, warnings
 warnings.filterwarnings("ignore")
 
 from typing import List, Tuple, Dict, Optional
@@ -9,75 +7,62 @@ from typing import List, Tuple, Dict, Optional
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
-import gradio as gr
+from matplotlib.ticker import PercentFormatter
 from PIL import Image
+
+import gradio as gr
 import requests
 import yfinance as yf
 
-# Embeddings
-from sentence_transformers import SentenceTransformer, util
+# Optional embeddings (lazy-loaded)
+_EMBED_MODEL = None
+def get_embed_model():
+    global _EMBED_MODEL
+    if _EMBED_MODEL is None:
+        try:
+            from sentence_transformers import SentenceTransformer
+            _EMBED_MODEL = SentenceTransformer("FinLang/finance-embeddings-investopedia")
+        except Exception as e:
+            _EMBED_MODEL = False
+    return _EMBED_MODEL
 
 # ---------------- config ----------------
 DATA_DIR = "data"
-DATASET_PATH = os.path.join(DATA_DIR, "investor_profiles.csv")
+os.makedirs(DATA_DIR, exist_ok=True)
 
-MAX_TICKERS = 30
+MARKET_TICKER = "VOO"      # “market” proxy
 DEFAULT_LOOKBACK_YEARS = 5
-MARKET_TICKER = "VOO"  # will auto-fallback to SPY if VOO missing
+MAX_TICKERS = 30
+SYNTH_ROWS = 1000
 
+# UI tables
 POS_COLS = ["ticker", "amount_usd", "weight_exposure", "beta"]
-SUG_COLS = ["ticker", "suggested_weight_pct"]
+SUG_COLS = ["pick", "ticker", "weight_exposure", "er_%", "sigma_%", "beta"]
 
+# FRED tenor map
 FRED_MAP = [
-    (1,  "DGS1"),
-    (2,  "DGS2"),
-    (3,  "DGS3"),
-    (5,  "DGS5"),
-    (7,  "DGS7"),
-    (10, "DGS10"),
-    (20, "DGS20"),
-    (30, "DGS30"),
-    (100, "DGS30"),
+    (1,  "DGS1"),  (2,  "DGS2"),  (3,  "DGS3"),
+    (5,  "DGS5"),  (7,  "DGS7"),  (10, "DGS10"),
+    (20, "DGS20"), (30, "DGS30"), (100, "DGS30"),
 ]
 
-# Embedding model cfg
-EMB_MODEL_NAME = "FinLang/finance-embeddings-investopedia"
-
-# ---------------- globals (runtime) ----------------
+# Session globals
 HORIZON_YEARS = 5.0
 RF_CODE = "DGS5"
-RF_ANN = 0.03
-
-UNIVERSE: List[str] = [MARKET_TICKER, "QQQ", "XLK", "XLP", "XLE", "VNQ", "IEF", "HYG", "GLD", "EEM"]
+RF_ANN = 0.02
 
-LAST_DATASET_PATH: Optional[str] = None
-LAST_UNIVERSE: Optional[List[str]] = None
-LAST_PLOT_STATE: Optional[Dict[str, float]] = None
-
-# embedding caches
-_EMB_MODEL = None
-_DS_TEXTS = None
-_DS_EMBS = None
-_DS_CACHE_KEY = None   # (csv_path, tuple(universe))
-
-
-# ---------------- helpers ----------------
 def ensure_data_dir():
     os.makedirs(DATA_DIR, exist_ok=True)
 
+def dataset_path_for_universe(universe: List[str]) -> str:
+    # unique file per universe (order-independent)
+    key = hashlib.sha256((",".join(sorted(universe))).encode()).hexdigest()[:10]
+    return os.path.join(DATA_DIR, f"investor_profiles_{key}.csv")
 
-def empty_positions_df():
-    return pd.DataFrame(columns=POS_COLS)
-
-
-def empty_suggest_df():
-    return pd.DataFrame(columns=SUG_COLS)
-
-
+# ---------------- tiny utils ----------------
 def fmt_pct(x: float) -> str:
     return f"{x*100:.2f}%"
 
-
 def fred_series_for_horizon(years: float) -> str:
     y = max(1.0, min(100.0, float(years)))
     for cutoff, code in FRED_MAP:
@@ -85,7 +70,6 @@ def fred_series_for_horizon(years: float) -> str:
             return code
     return "DGS30"
 
-
 def fetch_fred_yield_annual(code: str) -> float:
     url = f"https://fred.stlouisfed.org/graph/fredgraph.csv?id={code}"
     try:
@@ -97,8 +81,7 @@ def fetch_fred_yield_annual(code: str) -> float:
     except Exception:
         return 0.03
 
-
-# -------- Yahoo symbol search ----------
+# ---------------- Yahoo search ----------------
 def yahoo_search(query: str):
     if not query or len(query.strip()) == 0:
         return []
@@ -117,169 +100,93 @@ def yahoo_search(query: str):
             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"}]
+            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"}]
-
-
-# --------- prices / returns ----------
-def _extract_close(df: pd.DataFrame, tickers: List[str]) -> pd.DataFrame:
-    """
-    Robustly extract a (date x ticker) Close DataFrame regardless of yf's column layout.
-    """
-    if isinstance(df.columns, pd.MultiIndex):
-        lv0 = df.columns.get_level_values(0)
-        lv1 = df.columns.get_level_values(1)
-        if "Close" in lv0:
-            close = df["Close"]
-        elif "Adj Close" in lv0:
-            close = df["Adj Close"]
-        elif "Close" in lv1:
-            close = df.xs("Close", level=1, axis=1)
-        elif "Adj Close" in lv1:
-            close = df.xs("Adj Close", level=1, axis=1)
-        else:
-            # fallback: if first level are tickers
-            # try to select 'Close' under each
-            try:
-                close = df.xs("Close", level=1, axis=1)
-            except Exception:
-                close = df.copy()
-    else:
-        # Single ticker case
-        if "Close" in df.columns:
-            s = df["Close"].copy()
-        elif "Adj Close" in df.columns:
-            s = df["Adj Close"].copy()
-        else:
-            # last resort: take any one numeric column
-            s = df.select_dtypes(include=[np.number]).iloc[:, 0]
-        # ensure column named as ticker
-        name = tickers[0] if len(tickers) else "T0"
-        close = s.to_frame(name=name)
-
-    # Reindex columns to requested order where possible
-    # If some symbols missing, they simply won't be present
-    close = close.dropna(how="all").ffill()
-    # Keep only requested tickers, in order
-    cols = [c for c in tickers if c in close.columns]
-    if not cols:  # if nothing matched, keep whatever is there
-        close = close.copy()
-    else:
-        close = close[cols]
-    return close
-
+        return [{"symbol": query.strip().upper(), "name": "typed symbol", "exchange": "n/a"}]
 
 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")
-    dl = yf.download(
+    df = yf.download(
         list(dict.fromkeys(tickers)),
-        start=start.date(),
-        end=end.date(),
-        interval="1mo",
-        auto_adjust=True,
-        progress=False
-    )
-    close = _extract_close(dl, tickers)
-    return close
-
+        start=start.date(), end=end.date(),
+        interval="1mo", auto_adjust=True, progress=False
+    )["Close"]
+    if isinstance(df, pd.Series):
+        df = df.to_frame()
+    df = df.dropna(how="all").fillna(method="ffill")
+    return df
 
 def monthly_returns(prices: pd.DataFrame) -> pd.DataFrame:
-    return prices.pct_change().dropna(how="all")
-
-
-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)
-
+    return prices.pct_change().dropna()
 
 def validate_tickers(symbols: List[str], years: int) -> List[str]:
-    uniq = list(dict.fromkeys(symbols))
-    df = fetch_prices_monthly(uniq, years)
-    ok = [s for s in uniq if s in df.columns]
+    ok, df = [], fetch_prices_monthly(list(set(symbols)), years)
+    for s in symbols:
+        if s in df.columns:
+            ok.append(s)
     return ok
 
-
-# -------------- aligned moments --------------
+# ---------------- moments (aligned) ----------------
 def get_aligned_monthly_returns(symbols: List[str], years: int) -> pd.DataFrame:
-    uniq = [c for c in dict.fromkeys(symbols) if c]
-    tickers = uniq.copy()
-
-    # Ensure market present (try MARKET_TICKER then fallback to SPY)
-    market_ok = MARKET_TICKER in tickers
-    if not market_ok:
-        tickers.append(MARKET_TICKER)
-
+    uniq = [c for c in dict.fromkeys(symbols) if c != MARKET_TICKER]
+    tickers = uniq + [MARKET_TICKER]
     px = fetch_prices_monthly(tickers, years)
-    if MARKET_TICKER not in px.columns:
-        # fallback to SPY if VOO missing
-        if "SPY" not in tickers:
-            tickers.append("SPY")
-            px2 = fetch_prices_monthly(tickers, years)
-            if "SPY" in px2.columns:
-                px = px2
-            else:
-                pass  # keep px as-is
-
     rets = monthly_returns(px)
-    keep = [c for c in uniq if c in rets.columns]
-    if MARKET_TICKER in rets.columns:
-        keep += [MARKET_TICKER]
-    elif "SPY" in rets.columns:
-        keep += ["SPY"]
-    R = rets[keep].dropna(how="any")
+    cols = [c for c in uniq if c in rets.columns] + ([MARKET_TICKER] if MARKET_TICKER in rets.columns else [])
+    R = rets[cols].dropna(how="any")
     return R.loc[:, ~R.columns.duplicated()]
 
-
 def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
-    R = get_aligned_monthly_returns(symbols, years)
-    mkt_col = MARKET_TICKER if MARKET_TICKER in R.columns else ("SPY" if "SPY" in R.columns else None)
-    if mkt_col is None or R.shape[0] < 3:
-        raise ValueError("Not enough aligned data including market")
+    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 market data")
 
     rf_m = rf_ann / 12.0
-    m = R[mkt_col]
+
+    # market series
+    m = R[MARKET_TICKER]
     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
     var_m = float(np.var(ex_m.values, ddof=1))
-    var_m = max(var_m, 1e-8)
+    var_m = max(var_m, 1e-10)
 
+    # betas for each asset (including market==1)
     betas: Dict[str, float] = {}
-    for s in [c for c in R.columns if c != mkt_col]:
+    for s in R.columns:
+        if s == MARKET_TICKER:
+            betas[s] = 1.0
+            continue
         ex_s = R[s] - rf_m
-        betas[s] = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1] / var_m)
-    betas[mkt_col] = 1.0  # definition
-
-    asset_cols = [c for c in R.columns if c != mkt_col]
-    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, "mkt_col": mkt_col}
+        cov_sm = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1])
+        betas[s] = float(cov_sm / var_m)
+
+    # IMPORTANT FIX: include MARKET in covariance so σ is never understated
+    asset_cols = list(R.columns)
+    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(np.zeros((0, 0)))
 
+    return {"betas": betas, "cov_ann": covA, "erp_ann": erp_ann, "sigma_m_ann": sigma_m_ann}
 
 def capm_er(beta: float, rf_ann: float, erp_ann: float) -> float:
     return float(rf_ann + beta * erp_ann)
 
-
 def portfolio_stats(weights: Dict[str, float],
                     cov_ann: pd.DataFrame,
                     betas: Dict[str, float],
                     rf_ann: float,
                     erp_ann: float) -> Tuple[float, float, float]:
     tickers = list(weights.keys())
-    if len(tickers) == 0:
-        return 0.0, 0.0, 0.0
     w = np.array([weights[t] for t in tickers], dtype=float)
     gross = float(np.sum(np.abs(w)))
     if gross == 0:
@@ -291,58 +198,67 @@ def portfolio_stats(weights: Dict[str, float],
     sigma_p = math.sqrt(float(max(w_expo.T @ cov @ w_expo, 0.0)))
     return beta_p, er_p, sigma_p
 
-
-# -------------- CML helpers --------------
+# ---------------- CML helpers & plot ----------------
 def efficient_same_sigma(sigma_target: float, rf_ann: float, erp_ann: float, sigma_mkt: float):
     if sigma_mkt <= 1e-12:
         return 0.0, 1.0, rf_ann
     a = sigma_target / sigma_mkt
-    return a, 1.0 - a, rf_ann + a * erp_ann
-
+    return a, 1 - 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
+    return a, 1 - a, abs(a) * sigma_mkt
 
-
-def plot_cml(
-    rf_ann, erp_ann, sigma_mkt,
-    pt_sigma, pt_mu,
-    same_sigma_sigma, same_sigma_mu,
-    same_mu_sigma, same_mu_mu,
-    targ_sigma=None, targ_mu=None
-) -> Image.Image:
+def plot_cml_percent(rf_ann, erp_ann, sigma_mkt,
+                     pt_sigma, pt_mu,
+                     same_sigma_sigma, same_sigma_mu,
+                     same_mu_sigma, same_mu_mu,
+                     suggestion: Optional[Tuple[float, float]] = None) -> Image.Image:
     fig = plt.figure(figsize=(6, 4), dpi=120)
 
     xmax = max(
         0.3,
         sigma_mkt * 2.0,
         pt_sigma * 1.4,
-        (same_mu_sigma or 0.0) * 1.4,
-        (same_sigma_sigma or 0.0) * 1.4,
-        (targ_sigma or 0.0) * 1.4,
+        same_sigma_sigma * 1.4,
+        same_mu_sigma * 1.4,
+        (suggestion[0] if suggestion else 0.0) * 1.5,
     )
     xs = np.linspace(0, xmax, 160)
     slope = erp_ann / max(sigma_mkt, 1e-12)
     cml = rf_ann + slope * xs
-    plt.plot(xs, cml, label="CML via Market", linewidth=2.0)
+    plt.plot(xs, cml, label="CML via Market")
 
-    # key points
+    # Points
     plt.scatter([0.0], [rf_ann], label="Risk-free (FRED)")
-    plt.scatter([sigma_mkt], [rf_ann + erp_ann], label="Market")
-    plt.scatter([pt_sigma], [pt_mu], label="Your portfolio", marker="D")
-
-    if same_sigma_sigma is not None and same_sigma_mu is not None:
-        plt.scatter([same_sigma_sigma], [same_sigma_mu], label="Efficient same sigma", marker="o")
-    if same_mu_sigma is not None and same_mu_mu is not None:
-        plt.scatter([same_mu_sigma], [same_mu_mu], label="Efficient same return", marker="o")
-    if targ_sigma is not None and targ_mu is not None:
-        plt.scatter([targ_sigma], [targ_mu], label="Suggestion", marker="X", s=70)
+    plt.scatter([sigma_mkt], [rf_ann + erp_ann], label=f"Market {MARKET_TICKER}")
+    plt.scatter([pt_sigma], [pt_mu], label="Your portfolio")
+    plt.scatter([same_sigma_sigma], [same_sigma_mu], label="Efficient same sigma")
+    plt.scatter([same_mu_sigma], [same_mu_mu], label="Efficient same return")
+    if suggestion is not None:
+        plt.scatter([suggestion[0]], [suggestion[1]], marker="X", s=70, label="Suggestion")
+
+    # Guides (percent annotated)
+    plt.plot([pt_sigma, same_sigma_sigma], [pt_mu, same_sigma_mu], ls="--", lw=1.0, alpha=0.7, c="gray")
+    d_ret = (same_sigma_mu - pt_mu) * 100.0
+    plt.annotate(f"Return gain at same σ {d_ret:+.2f}%",
+                 xy=(same_sigma_sigma, same_sigma_mu),
+                 xytext=(same_sigma_sigma, same_sigma_mu + 0.03),
+                 arrowprops=dict(arrowstyle="->", lw=1.0), fontsize=9, ha="center")
+
+    plt.plot([pt_sigma, same_mu_sigma], [pt_mu, same_mu_mu], ls="--", lw=1.0, alpha=0.7, c="gray")
+    d_sig = (same_mu_sigma - pt_sigma) * 100.0
+    plt.annotate(f"Risk change at same μ {d_sig:+.2f}%",
+                 xy=(same_mu_sigma, same_mu_mu),
+                 xytext=(same_mu_sigma + 0.01, same_mu_mu),
+                 arrowprops=dict(arrowstyle="->", lw=1.0), fontsize=9, va="center")
 
     plt.xlabel("σ (annualized)")
     plt.ylabel("Expected return (annual)")
+    plt.gca().xaxis.set_major_formatter(PercentFormatter(1.0))
+    plt.gca().yaxis.set_major_formatter(PercentFormatter(1.0))
     plt.legend(loc="best")
     plt.tight_layout()
 
@@ -352,195 +268,181 @@ def plot_cml(
     buf.seek(0)
     return Image.open(buf)
 
-
-def _overlay_plot_with_suggestion(sigma_sugg: Optional[float], mu_sugg: Optional[float]) -> Optional[Image.Image]:
-    if LAST_PLOT_STATE is None:
-        return None
-    s = LAST_PLOT_STATE
-    return plot_cml(
-        s["rf_ann"], s["erp_ann"], s["sigma_mkt"],
-        s["pt_sigma"], s["pt_mu"],
-        s["pt_sigma"], s["mu_eff_sigma"],
-        s["sigma_eff_mu"], s["pt_mu"],
-        targ_sigma=sigma_sugg, targ_mu=mu_sugg
-    )
-
-
-# -------------- synthetic dataset (1,000 rows over *current* universe) --------------
-def build_synthetic_dataset(universe: List[str], years: int, rf_ann: float, erp_ann: float) -> pd.DataFrame:
-    # Always include market column used in cov/beta (if present)
-    symbols = list(sorted(set([s for s in universe if s] )))[:MAX_TICKERS]
-    moms = estimate_all_moments_aligned(symbols, years, rf_ann)
-    covA, betas = moms["cov_ann"], moms["betas"]
-
-    rows, rng = [], np.random.default_rng(123)
-    n = 1000
-    for i in range(n):
+# ---------------- synthetic dataset ----------------
+def synth_profile(seed: int) -> str:
+    rng = np.random.default_rng(seed)
+    risk = rng.choice(["cautious", "balanced", "moderate", "growth", "aggressive"])
+    horizon = rng.choice(["3y", "5y", "7y", "10y", "15y"])
+    goal = rng.choice(["retirement", "first home", "education", "wealth building", "travel", "emergency"])
+    return f"{risk} investor, {horizon} horizon, goal {goal}"
+
+def build_synthetic_dataset(universe: List[str],
+                            covA: pd.DataFrame,
+                            betas: Dict[str, float],
+                            rf_ann: float,
+                            erp_ann: float,
+                            rows: int = SYNTH_ROWS) -> pd.DataFrame:
+    # Ensure MARKET in universe (we may sample it too)
+    symbols = list(sorted(set(universe + [MARKET_TICKER])))[:MAX_TICKERS]
+    rng = np.random.default_rng(123)
+    data = []
+    for i in range(rows):
         k = rng.integers(low=min(2, len(symbols)), high=min(8, len(symbols)) + 1)
         picks = list(rng.choice(symbols, size=k, replace=False))
-        signs = rng.choice([-1.0, 1.0], size=k, p=[0.20, 0.80])
+        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
-        # compute stats from CAPM + cov
-        beta_p, er_p, sigma_p = portfolio_stats({picks[j]: w[j] for j in range(k)}, covA, betas, rf_ann, erp_ann)
-        rows.append({
+        wmap = {picks[j]: w[j] for j in range(k)}
+
+        beta_p, er_p, sigma_p = portfolio_stats(wmap, covA, betas, rf_ann, erp_ann)
+        data.append({
             "id": i,
+            "profile_text": synth_profile(10_000 + i),
             "tickers": ",".join(picks),
-            "weights": ",".join(f"{x:.6f}" for x in w),
+            "weights": ",".join(f"{x:.5f}" for x in w),
+            "beta_p": beta_p,
             "er_p": er_p,
-            "sigma_p": sigma_p,
-            "beta_p": beta_p
+            "sigma_p": sigma_p
         })
+    return pd.DataFrame(data)
 
-    return pd.DataFrame(rows)
-
-
-def save_synth_csv(df: pd.DataFrame, path: str = DATASET_PATH):
+def save_synth_csv(df: pd.DataFrame, path: str):
     os.makedirs(os.path.dirname(path), exist_ok=True)
     df.to_csv(path, index=False)
 
+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)}
+        x = np.array([wmap.get(t, 0.0) for t in universe], dtype=float)
+        gross = float(np.sum(np.abs(x)))
+        if gross <= 1e-12:
+            return None
+        return x / gross
+    except Exception:
+        return None
 
-# ---------------- Embeddings helpers ----------------
-def _get_emb_model():
-    global _EMB_MODEL
-    if _EMB_MODEL is None:
-        _EMB_MODEL = SentenceTransformer(EMB_MODEL_NAME)
-    return _EMB_MODEL
-
-
-def _weights_top_phrase(universe, w, top=4):
-    pairs = sorted([(universe[i], abs(float(w[i]))) for i in range(len(universe))],
-                   key=lambda t: -t[1])[:top]
-    parts = [f"{t} {p*100:.1f}%" for t, p in pairs if p > 1e-4]
-    return ", ".join(parts)
-
-
-def portfolio_to_sentence(universe, w, er, sigma, beta):
-    return (f"portfolio with volatility {sigma*100:.2f} percent, "
-            f"expected return {er*100:.2f} percent, beta {beta:.2f}, "
-            f"weights mostly in {_weights_top_phrase(universe, w)}")
-
+def candidate_text(weights_map: Dict[str, float], er: float, sigma: float, beta: float) -> str:
+    top = sorted(weights_map.items(), key=lambda kv: -abs(kv[1]))[:6]
+    parts = [f"{k} {v:+.2f}" for k, v in top]
+    return (
+        f"portfolio with expected return {er:.4f}, volatility {sigma:.4f}, beta {beta:.2f}. "
+        f"top exposures: {'; '.join(parts)}"
+    )
 
-def build_ds_embeddings(csv_path: str, universe: list):
-    global _DS_TEXTS, _DS_EMBS, _DS_CACHE_KEY
-    cache_key = (csv_path, tuple(universe))
-    if _DS_EMBS is not None and _DS_CACHE_KEY == cache_key:
-        return _DS_TEXTS, _DS_EMBS
+def dataset_suggestions(csv_path: str,
+                        universe: List[str],
+                        risk_level: str,
+                        use_embeddings: bool,
+                        top_k: int = 3):
+    try:
+        df = pd.read_csv(csv_path)
+    except Exception:
+        return []
 
-    df = pd.read_csv(csv_path)
-    texts = []
+    # Build rows usable for this universe
     rows = []
     for _, r in df.iterrows():
-        ws = np.array([float(x) for x in str(r["weights"]).split(",")], dtype=float)
-        ts = [t.strip().upper() for t in str(r["tickers"]).split(",")]
-        wmap = {ts[i]: ws[i] for i in range(min(len(ts), len(ws)))}
-        w = np.array([wmap.get(t, 0.0) for t in universe], dtype=float)
-        g = np.sum(np.abs(w))
-        if g <= 1e-12:
+        x = _row_to_exposures(r, universe)
+        if x is None:
             continue
-        w = w / g
-        er = float(r["er_p"]); sigma = float(r["sigma_p"]); beta = float(r["beta_p"])
-        txt = portfolio_to_sentence(universe, w, er, sigma, beta)
-        texts.append(txt); rows.append((w, er, sigma, beta))
-
-    model = _get_emb_model()
-    embs = model.encode(texts, normalize_embeddings=True, show_progress_bar=False)
-    _DS_TEXTS, _DS_EMBS, _DS_CACHE_KEY = (rows, embs, cache_key)
-    return _DS_TEXTS, _DS_EMBS
-
-
-def pick_low_med_high(csv_path: str, universe: List[str]):
-    df = pd.read_csv(csv_path)
-    rows = []
-    for _, r in df.iterrows():
+        # recover a printable mapping for display
+        ts = [t.strip() for t in str(r["tickers"]).split(",")]
         ws = [float(x) for x in str(r["weights"]).split(",")]
-        ts = [t.strip().upper() for t in str(r["tickers"]).split(",")]
-        wmap = {ts[i]: ws[i] for i in range(min(len(ts), len(ws)))}
-        x = np.array([wmap.get(t, 0.0) for t in universe], dtype=float)
-        g = float(np.sum(np.abs(x)))
-        if g <= 1e-12:
-            continue
-        x = x / g
-        rows.append((x, float(r["er_p"]), float(r["sigma_p"]), float(r["beta_p"])))
+        wmap = {}
+        for i in range(min(len(ts), len(ws))):
+            wmap[ts[i]] = ws[i]
+        gross = sum(abs(v) for v in wmap.values()) or 1.0
+        wmap = {k: v / gross for k, v in wmap.items()}
+        rows.append((wmap, float(r["er_p"]), float(r["sigma_p"]), float(r["beta_p"])))
+
     if not rows:
-        return None
-    rows_sorted = sorted(rows, key=lambda t: t[2])  # by sigma
-    return rows_sorted
-
-
-def _band_indices(n, level):
-    if level == "low":
-        return range(0, max(1, int(0.25 * n)))
-    if level == "medium":
-        a, b = int(0.375 * n), int(0.625 * n)
-        return range(max(0, a), min(n, b))
-    return range(max(0, int(0.75 * n)), n)  # high
-
-
-def suggest_level(level: str):
-    if not LAST_DATASET_PATH or not os.path.exists(LAST_DATASET_PATH) or not LAST_UNIVERSE:
-        return empty_suggest_df(), "Run Compute first.", None
-    rows_texts, embs = build_ds_embeddings(LAST_DATASET_PATH, LAST_UNIVERSE)
-    if not rows_texts:
-        return empty_suggest_df(), "No dataset rows.", None
-
-    n = len(rows_texts)
-    band = list(_band_indices(n, level))
-    if not band:
-        return empty_suggest_df(), "No rows in band.", None
-
-    prompts = {
-        "low": "conservative low-risk portfolio with low volatility and low beta",
-        "medium": "balanced moderate-risk portfolio with moderate volatility and beta around 1",
-        "high": "aggressive high-risk growth portfolio with high volatility and beta above 1",
-    }
-    q = prompts.get(level, "balanced portfolio")
-    model = _get_emb_model()
-    q_emb = model.encode([q], normalize_embeddings=True)
-    band_embs = embs[band]
-    sims = util.cos_sim(q_emb, band_embs).cpu().numpy()[0]
-    best_idx_in_band = int(np.argmax(sims))
-    x, er_p, sig_p, beta_p = rows_texts[band[best_idx_in_band]]
-
-    rows_df = [{"ticker": LAST_UNIVERSE[i], "suggested_weight_pct": float(x[i]) * 100.0}
-               for i in range(len(LAST_UNIVERSE))]
-    df = pd.DataFrame(rows_df, columns=SUG_COLS).sort_values("suggested_weight_pct", ascending=False)
-    msg = f"{level.capitalize()} risk (embedding-ranked) → ER {fmt_pct(er_p)}, Sigma {fmt_pct(sig_p)}, Beta {beta_p:.2f}"
-    img = _overlay_plot_with_suggestion(sig_p, er_p)
-    return df, msg, img
-
-
-# -------------- summary builder --------------
+        return []
+
+    # Risk buckets by sigma
+    sigmas = np.array([r[2] for r in rows])
+    q10, q50, q90 = np.quantile(sigmas, [0.10, 0.50, 0.90])
+
+    if risk_level == "Low":
+        pool = [r for r in rows if r[2] <= q10]
+        target_sigma = q10
+        query = "low risk conservative stable portfolio minimize volatility"
+    elif risk_level == "High":
+        pool = [r for r in rows if r[2] >= q90]
+        target_sigma = q90
+        query = "high risk aggressive growth portfolio accept high volatility maximize returns"
+    else:
+        # Medium around median band
+        band = 0.03  # ±3% absolute sigma band around median
+        pool = [r for r in rows if abs(r[2] - q50) <= band]
+        if not pool:
+            # fallback: closest N to median
+            pool = sorted(rows, key=lambda r: abs(r[2] - q50))[: max(10, top_k)]
+        target_sigma = q50
+        query = "balanced moderate risk diversified portfolio"
+
+    if not pool:
+        # fallback: take closest overall
+        pool = sorted(rows, key=lambda r: abs(r[2] - target_sigma))[: max(10, top_k)]
+
+    # Rank inside pool
+    if use_embeddings and get_embed_model():
+        try:
+            model = get_embed_model()
+            texts = [candidate_text(*r) for r in pool]
+            embs = model.encode([query] + texts, normalize_embeddings=True)
+            qv = embs[0:1]
+            tv = embs[1:]
+            sims = (tv @ qv.T).ravel()
+            ranked = [pool[i] for i in np.argsort(-sims)]
+        except Exception:
+            ranked = sorted(pool, key=lambda r: abs(r[2] - target_sigma))
+    else:
+        ranked = sorted(pool, key=lambda r: abs(r[2] - target_sigma))
+
+    picks = ranked[:top_k]
+    out = []
+    for i, (wmap, er, sigma, beta) in enumerate(picks, start=1):
+        # normalize for display
+        gross = sum(abs(v) for v in wmap.values()) or 1.0
+        wmap = {k: v / gross for k, v in wmap.items()}
+        out.append({"pick": i, "weights": wmap, "er": er, "sigma": sigma, "beta": beta})
+    return out
+
+# ---------------- summary ----------------
 def build_summary_md(lookback, horizon, rf, rf_code, erp, sigma_mkt,
                      beta_p, er_p, sigma_p,
                      a_sigma, b_sigma, mu_eff_sigma,
-                     a_mu, b_mu, sigma_eff_mu) -> str:
+                     a_mu, b_mu, sigma_eff_mu,
+                     risk_level: str,
+                     suggestion: Optional[Dict] = None) -> str:
     lines = []
     lines.append("### Inputs")
-    lines.append(f"- Lookback years **{lookback}**")
-    lines.append(f"- Horizon years **{int(round(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(f"- Lookback years: **{int(lookback)}**")
+    lines.append(f"- Horizon years: **{int(round(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"- σ **{fmt_pct(sigma_p)}**")
-    lines.append(f"- Expected return **{fmt_pct(er_p)}**")
+    lines.append(f"- Beta: **{beta_p:.2f}**")
+    lines.append(f"- σ: **{fmt_pct(sigma_p)}**")
+    lines.append(f"- Expected return: **{fmt_pct(er_p)}**")
     lines.append("")
     lines.append("### Efficient alternatives on CML")
-    lines.append("**Same σ as your portfolio**")
-    lines.append(f"- Market weight **{a_sigma:.2f}**, Bills weight **{b_sigma:.2f}**")
-    lines.append(f"- Expected return **{fmt_pct(mu_eff_sigma)}**")
+    lines.append(f"- Same σ: market **{a_sigma:.2f}**, bills **{b_sigma:.2f}**, μ **{fmt_pct(mu_eff_sigma)}**")
+    lines.append(f"- Same μ: market **{a_mu:.2f}**, bills **{b_mu:.2f}**, σ **{fmt_pct(sigma_eff_mu)}**")
     lines.append("")
-    lines.append("**Same expected return as your portfolio**")
-    lines.append(f"- Market weight **{a_mu:.2f}**, Bills weight **{b_mu:.2f}**")
-    lines.append(f"- σ **{fmt_pct(sigma_eff_mu)}**")
+    lines.append(f"### Dataset-based suggestions (risk = **{risk_level}**)")
+    if suggestion:
+        lines.append(f"- Top suggestion μ **{fmt_pct(suggestion['er'])}**, σ **{fmt_pct(suggestion['sigma'])}**, β **{suggestion['beta']:.2f}**")
+    else:
+        lines.append("- No suggestion available.")
     return "\n".join(lines)
 
-
-# -------------- gradio callbacks --------------
+# ---------------- gradio callbacks ----------------
 def search_tickers_cb(q: str):
     hits = yahoo_search(q)
     if not hits:
@@ -548,7 +450,6 @@ def search_tickers_cb(q: str):
     opts = [f"{h['symbol']}  |  {h['name']}  |  {h['exchange']}" for h in hits]
     return "Select a symbol and click Add", opts
 
-
 def add_symbol(selection: str, table: pd.DataFrame):
     if not selection:
         return table, "Pick a row from Matches first"
@@ -570,7 +471,6 @@ def add_symbol(selection: str, table: pd.DataFrame):
         msg = f"Reached max of {MAX_TICKERS}"
     return new_table, msg
 
-
 def lock_ticker_column(tb: pd.DataFrame):
     if tb is None or len(tb) == 0:
         return pd.DataFrame(columns=["ticker", "amount_usd"])
@@ -581,7 +481,6 @@ def lock_ticker_column(tb: pd.DataFrame):
     amounts = amounts[:len(tickers)] + [0.0] * max(0, len(tickers) - len(amounts))
     return pd.DataFrame({"ticker": tickers, "amount_usd": amounts})
 
-
 def set_horizon(years: float):
     y = max(1.0, min(100.0, float(years)))
     code = fred_series_for_horizon(y)
@@ -590,38 +489,40 @@ def set_horizon(years: float):
     HORIZON_YEARS = y
     RF_CODE = code
     RF_ANN = rf
-    return f"Risk free series {code}. Latest annual rate {rf:.2%}. Will be used for CAPM and CML."
-
-
-def compute(years_lookback: int, table: pd.DataFrame):
-    if table is None or len(table) == 0:
-        return None, "Add at least one ticker", "Universe empty", empty_positions_df(), empty_suggest_df(), None
+    return f"Risk free series {code}. Latest annual rate {rf:.2%}. Will be used on compute."
 
+def compute_and_suggest(years_lookback: int,
+                        table: pd.DataFrame,
+                        risk_level: str,
+                        use_embeddings: bool):
+    # sanitize table
     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(), empty_suggest_df(), None
+        return None, "Add at least one ticker", "Universe empty", pd.DataFrame(columns=POS_COLS), pd.DataFrame(columns=SUG_COLS), None
 
     symbols = validate_tickers(symbols, years_lookback)
     if len(symbols) == 0:
-        return None, "Could not validate any tickers", "Universe invalid", empty_positions_df(), empty_suggest_df(), None
+        return None, "Could not validate any tickers", "Universe invalid", pd.DataFrame(columns=POS_COLS), pd.DataFrame(columns=SUG_COLS), None
 
-    global UNIVERSE
-    UNIVERSE = list(sorted(set(symbols)))[:MAX_TICKERS]
+    # Universe includes market
+    universe = list(sorted(set([s for s in symbols] + [MARKET_TICKER])))[:MAX_TICKERS]
 
-    df = df[df["ticker"].isin(symbols)].copy()
-    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in df.iterrows()}
+    # amounts -> weights
+    dfp = df[df["ticker"].isin(symbols)].copy()
+    amounts = {r["ticker"]: float(r["amount_usd"]) for _, r in dfp.iterrows()}
     rf_ann = RF_ANN
 
-    moms = estimate_all_moments_aligned(UNIVERSE, years_lookback, rf_ann)
+    # historical moments
+    moms = estimate_all_moments_aligned(universe, years_lookback, rf_ann)
     betas, covA, erp_ann, sigma_mkt = moms["betas"], moms["cov_ann"], moms["erp_ann"], moms["sigma_m_ann"]
 
     gross = sum(abs(v) for v in amounts.values())
     if gross == 0:
-        return None, "All amounts are zero", "Universe ok", empty_positions_df(), empty_suggest_df(), None
+        return None, "All amounts are zero", "Universe ok", pd.DataFrame(columns=POS_COLS), pd.DataFrame(columns=SUG_COLS), None
     weights = {k: v / gross for k, v in amounts.items()}
 
     beta_p, er_p, sigma_p = portfolio_stats(weights, covA, betas, rf_ann, erp_ann)
@@ -629,53 +530,72 @@ def compute(years_lookback: int, table: pd.DataFrame):
     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(er_p, rf_ann, erp_ann, sigma_mkt)
 
-    img = plot_cml(
+    # Build synthetic dataset for THIS universe each run
+    ds_path = dataset_path_for_universe(universe)
+    synth_df = build_synthetic_dataset(universe, covA, betas, rf_ann, erp_ann, rows=SYNTH_ROWS)
+    save_synth_csv(synth_df, ds_path)
+
+    # Suggestions from dataset (top 3)
+    picks = dataset_suggestions(ds_path, universe, risk_level, use_embeddings, top_k=3)
+
+    # For plot, show first suggestion if any
+    first_sugg = None
+    if picks:
+        first_sugg = (float(picks[0]["sigma"]), float(picks[0]["er"]))
+
+    img = plot_cml_percent(
         rf_ann, erp_ann, sigma_mkt,
         sigma_p, er_p,
         sigma_p, mu_eff_sigma,
         sigma_eff_mu, er_p,
-        targ_sigma=None, targ_mu=None
+        suggestion=first_sugg
     )
 
+    # Build summary
     info = build_summary_md(
         years_lookback, HORIZON_YEARS, rf_ann, RF_CODE, erp_ann, sigma_mkt,
         beta_p, er_p, sigma_p,
         a_sigma, b_sigma, mu_eff_sigma,
-        a_mu, b_mu, sigma_eff_mu
+        a_mu, b_mu, sigma_eff_mu,
+        risk_level=risk_level,
+        suggestion=picks[0] if picks else None
     )
 
+    # Positions table
     rows = []
-    for t in UNIVERSE:
-        beta_val = 1.0 if abs(betas.get(t, 0.0) - 1.0) < 1e-6 else betas.get(t, np.nan)
+    for t in symbols:
         rows.append({
             "ticker": t,
             "amount_usd": amounts.get(t, 0.0),
             "weight_exposure": weights.get(t, 0.0),
-            "beta": beta_val,
+            "beta": 1.0 if t == MARKET_TICKER else betas.get(t, np.nan),
         })
     pos_table = pd.DataFrame(rows, columns=POS_COLS)
 
-    # build 1,000-row dataset over CURRENT universe
-    synth_df = build_synthetic_dataset(UNIVERSE, years=DEFAULT_LOOKBACK_YEARS, rf_ann=rf_ann, erp_ann=erp_ann)
-    save_synth_csv(synth_df, DATASET_PATH)
-
-    # update globals for suggestion buttons
-    global LAST_DATASET_PATH, LAST_UNIVERSE, LAST_PLOT_STATE
-    LAST_DATASET_PATH = DATASET_PATH
-    LAST_UNIVERSE = UNIVERSE.copy()
-    LAST_PLOT_STATE = {
-        "rf_ann": rf_ann, "erp_ann": erp_ann, "sigma_mkt": sigma_mkt,
-        "pt_sigma": sigma_p, "pt_mu": er_p,
-        "mu_eff_sigma": mu_eff_sigma, "sigma_eff_mu": sigma_eff_mu
-    }
-
-    uni_msg = f"Universe set to: {', '.join(UNIVERSE)} — dataset generated with 1,000 mixes."
-    return img, info, uni_msg, pos_table, empty_suggest_df(), DATASET_PATH
+    # Suggestions table (long format)
+    if picks:
+        sugg_rows = []
+        for p in picks:
+            for k, v in sorted(p["weights"].items(), key=lambda kv: -abs(kv[1]))[:12]:
+                sugg_rows.append({
+                    "pick": p["pick"],
+                    "ticker": k,
+                    "weight_exposure": v,
+                    "er_%": p["er"] * 100.0,
+                    "sigma_%": p["sigma"] * 100.0,
+                    "beta": p["beta"],
+                })
+        sugg_table = pd.DataFrame(sugg_rows, columns=SUG_COLS)
+    else:
+        sugg_table = pd.DataFrame(columns=SUG_COLS)
 
+    uni_msg = f"Universe set to: {', '.join(universe)}"
+    return img, info, uni_msg, pos_table, sugg_table, ds_path
 
-# -------------- UI --------------
+# ---------------- launch UI ----------------
 ensure_data_dir()
-# initial RF based on default horizon
+
+# Initialize risk-free from default horizon
 HORIZON_YEARS = 5.0
 RF_CODE = fred_series_for_horizon(HORIZON_YEARS)
 RF_ANN = fetch_fred_yield_annual(RF_CODE)
@@ -684,8 +604,9 @@ 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 use embeddings over a 1,000-mix dataset generated from your current universe."
+        "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**."
     )
 
     with gr.Row():
@@ -693,8 +614,9 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
             q = gr.Textbox(label="Search symbol")
             search_note = gr.Markdown()
             matches = gr.Dropdown(choices=[], label="Matches")
-            search_btn = gr.Button("Search")
-            add_btn = gr.Button("Add selected to portfolio")
+            with gr.Row():
+                search_btn = gr.Button("Search")
+                add_btn = gr.Button("Add selected to portfolio")
 
             gr.Markdown("### Portfolio positions — type dollar amounts (negatives allowed for shorts)")
             table = gr.Dataframe(
@@ -704,41 +626,38 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
                 col_count=(2, "fixed")
             )
 
-            horizon = gr.Number(label="Horizon in years (1–100)", value=5, precision=0)
-            lookback = gr.Slider(1, 10, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for beta and sigma")
+            horizon = gr.Number(label="Horizon in years (1–100)", value=int(HORIZON_YEARS), precision=0)
+            lookback = gr.Slider(1, 10, value=DEFAULT_LOOKBACK_YEARS, step=1, label="Lookback years for beta & sigma")
 
-            run_btn = gr.Button("Compute (build dataset & plot)")
+            gr.Markdown("### Suggestions")
+            risk_level = gr.Radio(["Low", "Medium", "High"], value="Medium", label="Risk tolerance")
+            use_embeddings = gr.Checkbox(label="Use finance embeddings to refine picks", value=True)
 
-            gr.Markdown("### Suggestions (dataset + embeddings)")
-            with gr.Row():
-                btn_low = gr.Button("Suggest LOW risk")
-                btn_med = gr.Button("Suggest MEDIUM risk")
-                btn_high = gr.Button("Suggest HIGH risk")
+            run_btn = gr.Button("Compute (build dataset & suggest)")
 
         with gr.Column(scale=1):
             plot = gr.Image(label="Capital Market Line (CML)", type="pil")
             summary = gr.Markdown(label="Summary")
-            universe_msg = gr.Textbox(label="Status", interactive=False)
+            universe_msg = gr.Textbox(label="Universe status", interactive=False)
             positions = gr.Dataframe(
                 label="Computed positions",
                 headers=POS_COLS,
                 datatype=["str", "number", "number", "number"],
                 col_count=(len(POS_COLS), "fixed"),
-                value=empty_positions_df(),
+                value=pd.DataFrame(columns=POS_COLS),
                 interactive=False
             )
             suggestions = gr.Dataframe(
-                label="Suggested portfolio (weights as % exposures)",
+                label="Dataset-based suggestions (top 3 — weights shown as exposures)",
                 headers=SUG_COLS,
-                datatype=["str", "number"],
+                datatype=["number", "str", "number", "number", "number", "number"],
                 col_count=(len(SUG_COLS), "fixed"),
-                value=empty_suggest_df(),
+                value=pd.DataFrame(columns=SUG_COLS),
                 interactive=False
             )
-            sugg_msg = gr.Textbox(label="Suggestion detail", interactive=False)
-            dl = gr.File(label="Generated dataset (CSV)", value=None, visible=True)
+            dl = gr.File(label="Generated dataset CSV", value=None, visible=True)
 
-    # wiring
+    # Wire up events
     def do_search(query):
         note, options = search_tickers_cb(query)
         return note, gr.update(choices=options)
@@ -749,26 +668,10 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
     horizon.change(fn=set_horizon, inputs=horizon, outputs=universe_msg)
 
     run_btn.click(
-        fn=compute,
-        inputs=[lookback, table],
+        fn=compute_and_suggest,
+        inputs=[lookback, table, risk_level, use_embeddings],
         outputs=[plot, summary, universe_msg, positions, suggestions, dl]
     )
 
-    def do_low():
-        df, msg, img = suggest_level("low")
-        return df, msg, (img if img is not None else gr.update())
-
-    def do_med():
-        df, msg, img = suggest_level("medium")
-        return df, msg, (img if img is not None else gr.update())
-
-    def do_high():
-        df, msg, img = suggest_level("high")
-        return df, msg, (img if img is not None else gr.update())
-
-    btn_low.click(fn=do_low, inputs=None, outputs=[suggestions, sugg_msg, plot])
-    btn_med.click(fn=do_med, inputs=None, outputs=[suggestions, sugg_msg, plot])
-    btn_high.click(fn=do_high, inputs=None, outputs=[suggestions, sugg_msg, plot])
-
 if __name__ == "__main__":
     demo.launch()