Milestone 3: Empirical Bayes adaptive shrinkage, Long-Only EM timing, Polymarket walk-forward capacity curve, Crypto regime-conditioned composite, and Microstructure Maker queue fee sensitivity
f784e93 verified | """Statistical and economic evaluation of out-of-sample forecasts.""" | |
| from __future__ import annotations | |
| import numpy as np | |
| import pandas as pd | |
| from scipy import stats | |
| def newey_west_t(x: np.ndarray, lags: int = 3) -> tuple[float, float]: | |
| """t-statistic and one-sided p-value (mean > 0) with Newey-West standard errors.""" | |
| x = np.asarray(x, dtype=float) | |
| x = x[~np.isnan(x)] | |
| n = len(x) | |
| if n < 10: | |
| return np.nan, np.nan | |
| d = x - x.mean() | |
| s = d @ d / n | |
| for k in range(1, min(lags, n - 1) + 1): | |
| w = 1 - k / (lags + 1) | |
| s += 2 * w * (d[k:] @ d[:-k]) / n | |
| se = np.sqrt(s / n) | |
| t = x.mean() / se if se > 0 else np.nan | |
| return t, 1 - stats.norm.cdf(t) | |
| def r2_table(preds: pd.DataFrame, lags: int = 3) -> pd.DataFrame: | |
| """Pooled out-of-sample R^2 against two benchmarks. | |
| R2_OS = 1 - sum (y - yhat)^2 / sum (y - bench)^2 (Campbell and Thompson 2008) | |
| hist = the factor's own expanding mean (the standard benchmark) | |
| shrink = that mean shrunk toward the regional mean of the same factor. A model | |
| can beat `hist` merely by pooling noisy means across countries; only | |
| beating `shrink` is evidence of time variation being forecast. | |
| Significance: Clark-West (2007) adjusted MSPE difference, 2 (y - b)(yhat - b), | |
| averaged across the cross-section each month; the monthly series is tested | |
| with Newey-West errors, so correlation within a month does not inflate t. | |
| """ | |
| rows = [] | |
| for (model, scope), g in preds.groupby(["model", "scope"]): | |
| y, p = g["target"].to_numpy(), g["pred"].to_numpy() | |
| row = {"model": model, "scope": scope} | |
| for tag, col in (("hist", "hist_mean"), ("shrink", "shrink_mean")): | |
| b = g[col].to_numpy() | |
| row[f"r2_vs_{tag}_pct"] = 100 * (1 - np.sum((y - p) ** 2) / np.sum((y - b) ** 2)) | |
| cw = 2 * (y - b) * (p - b) | |
| monthly = pd.Series(cw).groupby(g["target_month"].to_numpy()).mean().to_numpy() | |
| row[f"cw_t_{tag}"] = newey_west_t(monthly, lags)[0] if np.any(p != b) else np.nan | |
| row["obs"], row["months"] = len(g), g["target_month"].nunique() | |
| rows.append(row) | |
| return pd.DataFrame(rows).sort_values("r2_vs_shrink_pct", ascending=False).reset_index(drop=True) | |
| def r2_by_country(preds: pd.DataFrame, model: str, scope: str) -> pd.DataFrame: | |
| g = preds[(preds["model"] == model) & (preds["scope"] == scope)] | |
| rows = [] | |
| for c, h in g.groupby("country"): | |
| y, p = h["target"].to_numpy(), h["pred"].to_numpy() | |
| r2 = {f"r2_vs_{t}_pct": 100 * (1 - np.sum((y - p) ** 2) / np.sum((y - h[c2].to_numpy()) ** 2)) | |
| for t, c2 in (("hist", "hist_mean"), ("shrink", "shrink_mean"))} | |
| rows.append({"country": c, **r2, "obs": len(h)}) | |
| return pd.DataFrame(rows).sort_values("r2_vs_shrink_pct", ascending=False).reset_index(drop=True) | |
| def timing_weights(g: pd.DataFrame, how: str) -> np.ndarray: | |
| """Weights across factors within one country-month; gross exposure sums to 1.""" | |
| n = len(g) | |
| if how == "static": | |
| return np.full(n, 1.0 / n) | |
| if how == "sign": | |
| s = np.sign(g["pred"].to_numpy()) | |
| return s / max(np.abs(s).sum(), 1) | |
| if how == "long_only": | |
| p = np.maximum(g["pred"].to_numpy(), 0.0) | |
| tot = p.sum() | |
| return p / tot if tot > 0 else np.full(n, 1.0 / n) | |
| p = g["pred"].to_numpy() | |
| tot = np.abs(p).sum() | |
| return p / tot if tot > 0 else np.full(n, 1.0 / n) | |
| def portfolio_returns(preds: pd.DataFrame, cost_bps: float = 0.0) -> pd.DataFrame: | |
| """Monthly returns of timing portfolios, averaged equally across countries. | |
| For each model/scope the country portfolio holds each factor in proportion to | |
| its forecast (gross exposure 1). The static benchmark holds every factor | |
| equally. Turnover is sum |w_t - w_{t-1}| within a country; the cost applies | |
| only to these timing trades -- the factor returns themselves are gross of the | |
| costs of their own monthly rebalancing. | |
| """ | |
| out = [] | |
| static_done = False | |
| for (model, scope), g in preds.groupby(["model", "scope"]): | |
| variants = [("proportional", "prop")] | |
| if model == "fmom": | |
| variants = [("sign", "sign")] | |
| if not static_done: | |
| variants.append(("static", "static")) | |
| for label, how in variants: | |
| recs = [] | |
| for (country, tm), h in g.groupby(["country", "target_month"], sort=True): | |
| w = timing_weights(h, how) | |
| recs.append((country, tm, h["factor"].to_numpy(), w, float(w @ h["target"].to_numpy()))) | |
| df = pd.DataFrame(recs, columns=["country", "target_month", "factors", "w", "gross"]) | |
| df["turnover"] = 0.0 | |
| for country, h in df.groupby("country"): | |
| prev = None | |
| for i, row in h.iterrows(): | |
| cur = pd.Series(row["w"], index=row["factors"]) | |
| if prev is not None: | |
| df.at[i, "turnover"] = cur.sub(prev, fill_value=0).abs().sum() | |
| prev = cur | |
| df["net"] = df["gross"] - cost_bps / 1e4 * df["turnover"] | |
| monthly = df.groupby("target_month")[["gross", "net", "turnover"]].mean().reset_index() | |
| name = "static_ew" if how == "static" else f"{model}:{scope}" | |
| monthly["strategy"] = name | |
| out.append(monthly) | |
| if how == "static": | |
| static_done = True | |
| return pd.concat(out, ignore_index=True) | |
| def portfolio_table(monthly: pd.DataFrame) -> pd.DataFrame: | |
| rows = [] | |
| for s, g in monthly.groupby("strategy"): | |
| gr, nt = g["gross"].to_numpy(), g["net"].to_numpy() | |
| rows.append( | |
| { | |
| "strategy": s, | |
| "mean_ann_pct": 1200 * gr.mean(), | |
| "vol_ann_pct": 100 * np.sqrt(12) * gr.std(ddof=1), | |
| "sharpe_gross": np.sqrt(12) * gr.mean() / gr.std(ddof=1), | |
| "sharpe_net": np.sqrt(12) * nt.mean() / nt.std(ddof=1), | |
| "turnover_monthly": g["turnover"].mean(), | |
| "months": len(g), | |
| } | |
| ) | |
| return pd.DataFrame(rows).sort_values("sharpe_net", ascending=False).reset_index(drop=True) | |