Update app.py

app.py

@@ -23,9 +23,8 @@ MAX_TICKERS = 30
 DEFAULT_LOOKBACK_YEARS = 5
 MARKET_TICKER = "VOO"
 
-# column schemas (weights in percent for UI tables)
+# column schema (weights shown in percent in UI tables)
 POS_COLS = ["ticker", "amount_usd", "weight_%", "beta"]
-SUG_COLS = ["ticker", "suggested_weight_%"]
 
 FRED_MAP = [
     (1,  "DGS1"),
@@ -46,9 +45,6 @@ def ensure_data_dir():
 def empty_positions_df():
     return pd.DataFrame(columns=POS_COLS)
 
-def empty_suggest_df():
-    return pd.DataFrame(columns=SUG_COLS)
-
 def fred_series_for_horizon(years: float) -> str:
     y = max(1.0, min(100.0, float(years)))
     for cutoff, code in FRED_MAP:
@@ -57,7 +53,6 @@ def fred_series_for_horizon(years: float) -> str:
     return "DGS30"
 
 def fetch_fred_yield_annual(code: str) -> float:
-    # FRED CSV endpoint
     url = f"https://fred.stlouisfed.org/graph/fredgraph.csv?id={code}"
     try:
         r = requests.get(url, timeout=10)
@@ -69,7 +64,6 @@ def fetch_fred_yield_annual(code: str) -> float:
         return 0.03
 
 def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
-    # yfinance docs https://pypi.org/project/yfinance
     start = pd.Timestamp.today(tz="UTC") - pd.DateOffset(years=years, days=7)
     end = pd.Timestamp.today(tz="UTC")
     df = yf.download(
@@ -82,7 +76,7 @@ def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
     )["Close"]
     if isinstance(df, pd.Series):
         df = df.to_frame()
-    # Normalize column names to simple strings (yfinance can return MultiIndex)
+    # yfinance sometimes returns MultiIndex columns
     if isinstance(df.columns, pd.MultiIndex):
         df.columns = [c[-1] if isinstance(c, tuple) else str(c) for c in df.columns]
     else:
@@ -93,14 +87,10 @@ def fetch_prices_monthly(tickers: List[str], years: int) -> pd.DataFrame:
 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 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):
-    # Yahoo symbol search
     if not query or len(query.strip()) == 0:
         return []
     url = "https://query1.finance.yahoo.com/v1/finance/search"
@@ -133,16 +123,13 @@ def validate_tickers(symbols: List[str], years: int) -> List[str]:
 # -------------- aligned moments --------------
 def get_aligned_monthly_returns(symbols: List[str], years: int) -> pd.DataFrame:
     uniq = [c for c in dict.fromkeys(symbols)]
-    # Always append market for alignment
     if MARKET_TICKER not in uniq:
         uniq = uniq + [MARKET_TICKER]
     px = fetch_prices_monthly(uniq, years)
     rets = monthly_returns(px)
     cols = [c for c in uniq if c in rets.columns]
     R = rets[cols].dropna(how="any")
-    # Ensure unique simple columns
-    R = R.loc[:, ~R.columns.duplicated()]
-    return R
+    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)
@@ -170,7 +157,7 @@ def estimate_all_moments_aligned(symbols: List[str], years: int, rf_ann: float):
         elif ex_s is not None:
             betas[s] = float(np.cov(ex_s.values, ex_m.values, ddof=1)[0, 1] / var_m)
 
-    # IMPORTANT: include market in covariance to avoid under-estimating risk when VOO is held
+    # include market in covariance so risk is measured correctly when VOO is held
     asset_cols = list(R.columns)
     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)
@@ -232,7 +219,6 @@ def plot_cml(
     cml = rf_ann + slope * xs
     plt.plot(xs, cml, label="CML through VOO")
 
-    # Key points
     plt.scatter([0.0], [rf_ann], label="Risk free")
     plt.scatter([sigma_mkt], [rf_ann + erp_ann], label="Market VOO")
     plt.scatter([pt_sigma], [pt_mu], label="Your portfolio")
@@ -241,46 +227,23 @@ def plot_cml(
     if targ_sigma is not None and targ_mu is not None:
         plt.scatter([targ_sigma], [targ_mu], label="Target suggestion")
 
-    # Dotted guides and annotations that show the gap
-    # Same sigma guide, vertical gap in return
-    plt.plot(
-        [pt_sigma, same_sigma_sigma],
-        [pt_mu, same_sigma_mu],
-        linestyle="--",
-        linewidth=1.2,
-        alpha=0.7,
-        color="gray",
-    )
+    # Guides + annotations (in percent)
+    plt.plot([pt_sigma, same_sigma_sigma], [pt_mu, same_sigma_mu],
+             linestyle="--", linewidth=1.2, alpha=0.7, color="gray")
     d_ret = (same_sigma_mu - pt_mu) * 100.0
-    plt.annotate(
-        f"Return gain at same sigma {d_ret:+.2f}%",
-        xy=(same_sigma_sigma, same_sigma_mu),
-        xytext=(same_sigma_sigma + 0.02 * xmax, same_sigma_mu),
-        arrowprops=dict(arrowstyle="->", lw=1.0),
-        fontsize=9,
-        va="center",
-    )
+    plt.annotate(f"Return gain at same sigma {d_ret:+.2f}%",
+                 xy=(same_sigma_sigma, same_sigma_mu),
+                 xytext=(same_sigma_sigma + 0.02 * xmax, same_sigma_mu),
+                 arrowprops=dict(arrowstyle="->", lw=1.0), fontsize=9, va="center")
 
-    # Same return guide, horizontal gap in sigma
-    plt.plot(
-        [pt_sigma, same_mu_sigma],
-        [pt_mu, same_mu_mu],
-        linestyle="--",
-        linewidth=1.2,
-        alpha=0.7,
-        color="gray",
-    )
+    plt.plot([pt_sigma, same_mu_sigma], [pt_mu, same_mu_mu],
+             linestyle="--", linewidth=1.2, alpha=0.7, color="gray")
     d_sig = (same_mu_sigma - pt_sigma) * 100.0
-    plt.annotate(
-        f"Risk change at same return {d_sig:+.2f}%",
-        xy=(same_mu_sigma, same_mu_mu),
-        xytext=(same_mu_sigma, same_mu_mu + 0.03),
-        arrowprops=dict(arrowstyle="->", lw=1.0),
-        fontsize=9,
-        ha="center",
-    )
+    plt.annotate(f"Risk change at same return {d_sig:+.2f}%",
+                 xy=(same_mu_sigma, same_mu_mu),
+                 xytext=(same_mu_sigma, same_mu_mu + 0.03),
+                 arrowprops=dict(arrowstyle="->", lw=1.0), fontsize=9, ha="center")
 
-    # Percent axes
     ax = plt.gca()
     ax.yaxis.set_major_formatter(PercentFormatter(1.0))
     ax.xaxis.set_major_formatter(PercentFormatter(1.0))
@@ -295,7 +258,7 @@ def plot_cml(
     buf.seek(0)
     return Image.open(buf)
 
-# -------------- synthetic dataset --------------
+# -------------- synthetic dataset (for the optional predictor) --------------
 def synth_profile(seed: int) -> str:
     rng = np.random.default_rng(seed)
     risk = rng.choice(["cautious", "balanced", "moderate", "growth", "aggressive"])
@@ -331,7 +294,6 @@ def save_synth_csv(df: pd.DataFrame, path: str = DATASET_PATH):
     os.makedirs(os.path.dirname(path), exist_ok=True)
     df.to_csv(path, index=False)
 
-# ----------- surrogate from saved CSV only -----------
 def _row_to_exposures(row: pd.Series, universe: List[str]) -> Optional[np.ndarray]:
     try:
         ts = [t.strip() for t in str(row["tickers"]).split(",")]
@@ -377,53 +339,7 @@ def predict_from_surrogate(amounts_map: Dict[str, float], universe: List[str],
     er_hat, sigma_hat, beta_hat = float(yhat[0]), float(yhat[1]), float(yhat[2])
     return er_hat, sigma_hat, beta_hat
 
-# ----------- target search over synthetic dataset -----------
-def target_best_from_synth(csv_path: str,
-                           universe: List[str],
-                           target_mu: Optional[float],
-                           target_sigma: Optional[float]):
-    try:
-        df = pd.read_csv(csv_path)
-    except Exception:
-        return None
-
-    if target_mu is None and target_sigma is None:
-        return None
-
-    rows = []
-    for _, r in df.iterrows():
-        x = _row_to_exposures(r, universe)
-        if x is None:
-            continue
-        rows.append((x, float(r["er_p"]), float(r["sigma_p"]), float(r["beta_p"]), r))
-
-    if not rows:
-        return None
-
-    mu_w = 1.0
-    sig_w = 1.0
-    best = None
-    best_d = float("inf")
-    for x, er_p, sig_p, beta_p, r in rows:
-        d = 0.0
-        if target_mu is not None:
-            d += mu_w * (er_p - target_mu) ** 2
-        if target_sigma is not None:
-            d += sig_w * (sig_p - target_sigma) ** 2
-        if d < best_d:
-            best_d = d
-            best = (x, er_p, sig_p, beta_p, r)
-
-    if best is None:
-        return None
-
-    x, er_p, sig_p, beta_p, r = best
-    wmap = {t: float(x[i]) for i, t in enumerate(universe) if abs(float(x[i])) > 1e-4}
-    top = sorted(wmap.items(), key=lambda kv: -abs(kv[1]))[:12]
-    wmap_top = dict(top)
-    return {"weights": wmap_top, "er": er_p, "sigma": sig_p, "beta": beta_p}
-
-# -------------- summary builder --------------
+# -------------- summary --------------
 def fmt_pct(x: float) -> str:
     return f"{x*100:.2f}%"
 
@@ -435,18 +351,17 @@ def humanize_synth(er_hat, sigma_hat, beta_hat, dmu, dsig, dbeta):
     parts.append(f"- Predicted annual return {fmt_pct(er_hat)} , difference {fmt_pct(dmu)}")
     parts.append(f"- Predicted annual volatility {fmt_pct(sigma_hat)} , difference {fmt_pct(dsig)}")
     parts.append(f"- Predicted beta {beta_hat:.2f} , difference {dbeta:+.02f}")
-    if close_mu and close_sig and close_beta:
-        verdict = "The synthetic model matches the historical calculation closely. You can trust these quick predictions for similar mixes."
-    else:
-        verdict = "The synthetic model is not very close here. Rely more on the historical calculation for this mix."
+    verdict = ("The synthetic model matches the historical calculation closely. "
+               "You can trust these quick predictions for similar mixes."
+               if (close_mu and close_sig and close_beta)
+               else "The synthetic model is not very close here. Rely more on the historical calculation for this mix.")
     return "\n".join(parts + ["", f"**Verdict** {verdict}"])
 
 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,
-                     synth=None, synth_nrows: int = 0,
-                     targ=None) -> str:
+                     synth=None, synth_nrows: int = 0) -> str:
     lines = []
     lines.append("### Inputs")
     lines.append(f"- Lookback years {lookback}")
@@ -465,14 +380,6 @@ def build_summary_md(lookback, horizon, rf, rf_code, erp, sigma_mkt,
         lines.append("### Synthetic prediction from data/investor_profiles.csv")
         lines.append(f"- Samples used {synth_nrows}")
         lines.append(humanize_synth(er_hat, sigma_hat, beta_hat, dmu, dsig, dbeta))
-    if targ is not None:
-        lines.append("")
-        lines.append("### Target driven suggestion from synthetic dataset")
-        lines.append(f"- Suggested expected return {fmt_pct(targ['er'])}")
-        lines.append(f"- Suggested sigma {fmt_pct(targ['sigma'])}")
-        lines.append(f"- Suggested beta {targ['beta']:.2f}")
-        pretty = ", ".join([f"{k} {v*100:+.2f}%" for k, v in targ["weights"].items()])
-        lines.append(f"- Weights, exposure terms {pretty}")
     lines.append("")
     lines.append("### Efficient alternatives on CML")
     lines.append("Efficient same sigma")
@@ -539,20 +446,18 @@ def set_horizon(years: float):
     RF_ANN = rf
     return f"Risk free series {code}. Latest annual rate {rf:.2%}. Dataset will use this rate on compute."
 
-def compute(years_lookback: int, table: pd.DataFrame,
-            target_mu: Optional[float], target_sigma: Optional[float],
-            use_synth: bool):
+def compute(years_lookback: int, table: pd.DataFrame, use_synth: bool):
     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", empty_positions_df(), 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", empty_positions_df(), None
 
     global UNIVERSE
     UNIVERSE = list(sorted(set([s for s in symbols if s != MARKET_TICKER] + [MARKET_TICKER])))[:MAX_TICKERS]
@@ -566,7 +471,7 @@ def compute(years_lookback: int, table: pd.DataFrame,
 
     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", empty_positions_df(), 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)
@@ -574,7 +479,7 @@ 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)
 
-    # ensure dataset exists once
+    # ensure synthetic dataset exists once (for predictor only)
     if not os.path.exists(DATASET_PATH):
         synth_df = build_synthetic_dataset(
             universe=list(sorted(set(symbols + [MARKET_TICKER]))),
@@ -598,27 +503,12 @@ def compute(years_lookback: int, table: pd.DataFrame,
                     er_hat - er_p, sigma_hat - sigma_p, beta_hat - beta_p
                 )
 
-    # target driven suggestion from synthetic dataset
-    targ = None
-    targ_table = empty_suggest_df()
-    targ_sigma_plot = None
-    targ_mu_plot = None
-    if csv_path and (target_mu is not None or target_sigma is not None):
-        cand = target_best_from_synth(csv_path, UNIVERSE, target_mu, target_sigma)
-        if cand is not None:
-            targ = cand
-            targ_sigma_plot = cand["sigma"]
-            targ_mu_plot = cand["er"]
-            rows = [{"ticker": k, "suggested_weight_%": v * 100.0}
-                    for k, v in cand["weights"].items()]
-            targ_table = pd.DataFrame(rows, columns=SUG_COLS)
-
     img = plot_cml(
         rf_ann, erp_ann, sigma_mkt,
         sigma_p, er_p,
         sigma_p, mu_eff_sigma,
         sigma_eff_mu, er_p,
-        targ_sigma=targ_sigma_plot, targ_mu=targ_mu_plot
+        targ_sigma=None, targ_mu=None
     )
 
     info = build_summary_md(
@@ -626,8 +516,7 @@ def compute(years_lookback: int, table: pd.DataFrame,
         beta_p, er_p, sigma_p,
         a_sigma, b_sigma, mu_eff_sigma,
         a_mu, b_mu, sigma_eff_mu,
-        synth=synth_tuple, synth_nrows=nrows,
-        targ=targ
+        synth=synth_tuple, synth_nrows=nrows
     )
 
     rows = []
@@ -642,7 +531,7 @@ def compute(years_lookback: int, table: pd.DataFrame,
     pos_table = pd.DataFrame(rows, columns=POS_COLS)
 
     uni_msg = f"Universe set to {', '.join(UNIVERSE)}"
-    return img, info, uni_msg, pos_table, targ_table, csv_path
+    return img, info, uni_msg, pos_table, csv_path
 
 # -------------- UI --------------
 ensure_data_dir()
@@ -673,10 +562,7 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
             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 & sigma")
 
-            gr.Markdown("### Optional targets on the CML")
-            target_mu = gr.Number(label="Target expected return (annual, e.g. 0.12 = 12%)", value=None, precision=6)
-            target_sigma = gr.Number(label="Target sigma (annual, e.g. 0.18 = 18%)", value=None, precision=6)
-            use_synth = gr.Checkbox(label="Use synthetic predictor", value=True)
+            use_synth = gr.Checkbox(label="Use synthetic predictor (fast check)", value=True)
 
             run_btn = gr.Button("Compute and suggest")
         with gr.Column(scale=1):
@@ -691,15 +577,7 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
                 value=empty_positions_df(),
                 interactive=False
             )
-            suggestions = gr.Dataframe(
-                label="Suggested portfolio from targets",
-                headers=SUG_COLS,
-                datatype=["str", "number"],
-                col_count=(len(SUG_COLS), "fixed"),
-                value=empty_suggest_df(),
-                interactive=False
-            )
-            dl = gr.File(label="Session CSV path", value=None, visible=True)
+            dl = gr.File(label="Session CSV path (synthetic predictor data)", value=None, visible=True)
 
     def do_search(query):
         note, options = search_tickers_cb(query)
@@ -712,8 +590,8 @@ with gr.Blocks(title="Efficient Portfolio Advisor") as demo:
 
     run_btn.click(
         fn=compute,
-        inputs=[lookback, table, target_mu, target_sigma, use_synth],
-        outputs=[plot, summary, universe_msg, positions, suggestions, dl]
+        inputs=[lookback, table, use_synth],
+        outputs=[plot, summary, universe_msg, positions, dl]
     )
 
 if __name__ == "__main__":