| """Write the paper's results tables from one run directory. |
| |
| Every number in paper/tables/*.tex written by this script comes from the CSVs and |
| predictions of a single `python -m emft run`, so the paper can be regenerated |
| after any rerun instead of being edited by hand. |
| |
| python scripts/paper_tables.py --run reports/jkp_em --out paper/tables |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src")) |
|
|
| from emft.evaluate import newey_west_t |
|
|
| MODEL_LABEL = { |
| "ols": "OLS", "enet": "Elastic net", "gbrt": "Gradient-boosted trees", "nn": "Neural network", |
| "hist_mean": "Own historical mean", "shrink_mean": "Shrinkage mean", "fmom": "Factor momentum", |
| } |
| SCOPE_LABEL = {"own": "EM", "dm_only": "DM only", "pooled": "Pooled", "rule": "--"} |
| COUNTRY = { |
| "are": "United Arab Emirates", "bra": "Brazil", "chl": "Chile", "chn": "China", "col": "Colombia", |
| "cze": "Czech Republic", "egy": "Egypt", "grc": "Greece", "hun": "Hungary", "idn": "Indonesia", |
| "ind": "India", "kor": "Korea", "kwt": "Kuwait", "mex": "Mexico", "mys": "Malaysia", "per": "Peru", |
| "phl": "Philippines", "pol": "Poland", "qat": "Qatar", "sau": "Saudi Arabia", "tha": "Thailand", |
| "tur": "Turkey", "twn": "Taiwan", "zaf": "South Africa", |
| "aus": "Australia", "aut": "Austria", "bel": "Belgium", "can": "Canada", "che": "Switzerland", |
| "deu": "Germany", "dnk": "Denmark", "esp": "Spain", "fin": "Finland", "fra": "France", |
| "gbr": "United Kingdom", "hkg": "Hong Kong", "irl": "Ireland", "isr": "Israel", "ita": "Italy", |
| "jpn": "Japan", "nld": "Netherlands", "nor": "Norway", "nzl": "New Zealand", "prt": "Portugal", |
| "sgp": "Singapore", "swe": "Sweden", "usa": "United States", |
| } |
| LEARNED_ORDER = ["ols", "enet", "gbrt", "nn"] |
| SCOPE_ORDER = ["own", "dm_only", "pooled"] |
|
|
|
|
| def _f(x: float, d: int = 2) -> str: |
| return "--" if pd.isna(x) else f"{x:.{d}f}".replace("-", "$-$") |
|
|
|
|
| def _notes(text: str) -> list[str]: |
| return ["", r"\vspace{4pt}", r"\begin{minipage}{0.95\linewidth}\footnotesize", |
| r"\textit{Notes:} " + text, r"\end{minipage}"] |
|
|
|
|
| def coverage_table(cov: pd.DataFrame, manifest: dict) -> str: |
| cov = cov[cov["region"].isin(["DM", "EM"])].copy() |
| cov["name"] = cov["country"].map(COUNTRY) |
| lines = [r"\begin{table}[!ht]", r"\centering\footnotesize\setlength{\tabcolsep}{4pt}", |
| r"\caption{Coverage of the JKP factor returns by market}", r"\label{tab:coverage}", |
| r"\begin{tabular}{lrllr@{\hspace{6pt}}lrllr}", r"\toprule"] |
| half = r"Market & Factors & First & Last & Obs." |
| lines += [half + " & " + half + r" \\", r"\midrule"] |
| for reg, title in (("DM", "Developed markets"), ("EM", "Emerging markets")): |
| g = cov[cov["region"] == reg].sort_values("name").reset_index(drop=True) |
| lines.append(rf"\multicolumn{{10}}{{l}}{{\textit{{{title} ({len(g)})}}}} \\") |
| k = (len(g) + 1) // 2 |
| for i in range(k): |
| cells = [] |
| for j in (i, i + k): |
| if j < len(g): |
| r = g.loc[j] |
| cells += [r["name"], str(int(r["factors"])), r["first"], r["last"], f"{int(r['obs']):,}"] |
| else: |
| cells += [""] * 5 |
| lines.append(" & ".join(cells) + r" \\") |
| lines.append(r"\addlinespace") |
| lines += [r"\bottomrule", r"\end{tabular}"] |
| lines += _notes( |
| "Monthly capped value-weighted factor returns of \\citet{jensen2023replication}, downloaded from " |
| "jkpfactors.com. Country-factor-months in which a leg holds fewer than " |
| f"{manifest['min_stocks']} stocks are dropped. ``Obs.'' counts country-factor-months after that " |
| "filter. Markets are classified by the current MSCI classification.") |
| lines.append(r"\end{table}") |
| return "\n".join(lines) + "\n" |
|
|
|
|
| def forecast_slopes(preds: pd.DataFrame) -> pd.DataFrame: |
| """Pooled slope of the realised deviation from the shrinkage mean on the forecast deviation. |
| |
| Descriptive only: estimated on the whole out-of-sample period, so rescaling forecasts by |
| it would use future data. A slope between 0 and 1 means forecasts point the right way but |
| are too large, which is how a positive Clark-West statistic can accompany a negative R2. |
| """ |
| rows = [] |
| for (m, s), g in preds[preds["model"].isin(LEARNED_ORDER)].groupby(["model", "scope"]): |
| x = (g["pred"] - g["shrink_mean"]).to_numpy() |
| y = (g["target"] - g["shrink_mean"]).to_numpy() |
| rows.append({"model": m, "scope": s, "slope": float(x @ y / (x @ x)), |
| "sd_forecast_dev_pct": 100 * float(x.std())}) |
| return pd.DataFrame(rows) |
|
|
|
|
| def r2_table(r2: pd.DataFrame, manifest: dict, slopes: pd.DataFrame) -> str: |
| rows = [] |
| for m in LEARNED_ORDER: |
| for s in SCOPE_ORDER: |
| h = r2[(r2["model"] == m) & (r2["scope"] == s)] |
| if not h.empty: |
| rows.append(h.iloc[0]) |
| rules = [r2[(r2["model"] == m) & (r2["scope"] == "rule")] for m in ("fmom", "shrink_mean")] |
| first, last = manifest["oos_start"], manifest.get("last_year", "") |
| lines = [r"\begin{table}[!ht]", r"\centering\small\setlength{\tabcolsep}{4pt}", |
| rf"\caption{{Out-of-sample $R^2$ for emerging-market factor returns, {first}--{last}}}", |
| r"\label{tab:r2}", r"\begin{tabular}{llrrrrrr}", r"\toprule", |
| r" & & \multicolumn{2}{c}{vs.\ own historical mean} & \multicolumn{2}{c}{vs.\ shrinkage mean} & & \\", |
| r"\cmidrule(lr){3-4}\cmidrule(lr){5-6}", |
| r"Model & Training & $R^2_{OS}$ (\%) & CW $t$ & $R^2_{OS}$ (\%) & CW $t$ & Slope & Obs. \\", r"\midrule"] |
| sl = slopes.set_index(["model", "scope"])["slope"] |
| prev = None |
| for r in rows: |
| name = MODEL_LABEL[r["model"]] if r["model"] != prev else "" |
| prev = r["model"] |
| lines.append(f"{name} & {SCOPE_LABEL[r['scope']]} & {_f(r['r2_vs_hist_pct'], 3)} & {_f(r['cw_t_hist'])} & " |
| f"{_f(r['r2_vs_shrink_pct'], 3)} & {_f(r['cw_t_shrink'])} & " |
| f"{_f(sl.get((r['model'], r['scope']), np.nan))} & {int(r['obs']):,} \\\\") |
| lines.append(r"\addlinespace") |
| for h in rules: |
| if h.empty: |
| continue |
| r = h.iloc[0] |
| lines.append(f"{MODEL_LABEL[r['model']]} & -- & {_f(r['r2_vs_hist_pct'], 3)} & {_f(r['cw_t_hist'])} & " |
| f"{_f(r['r2_vs_shrink_pct'], 3)} & {_f(r['cw_t_shrink'])} & -- & {int(r['obs']):,} \\\\") |
| lines += [r"\bottomrule", r"\end{tabular}"] |
| lines += _notes( |
| "Pooled over all emerging-market country-factor-months. $R^2_{OS} = 1 - \\sum (r-\\hat r)^2 / " |
| "\\sum (r-b)^2$ for benchmark $b$. CW $t$ is the Clark--West statistic: the adjusted MSPE " |
| "difference is averaged across the cross-section each month and its mean tested with Newey--West " |
| "standard errors (3 lags); one-sided 5\\% critical value 1.645. Training scope: EM = emerging markets " |
| "only; DM only = developed markets only (the transfer test); Pooled = both. Learned models forecast " |
| "the deviation from the shrinkage mean and are refitted every January. The shrinkage mean is the " |
| "benchmark itself, so its own row against that benchmark is zero by construction. Slope: pooled " |
| "regression slope, without intercept, of $r-\\tilde r$ on $\\hat r-\\tilde r$ over the whole " |
| "out-of-sample period; a descriptive diagnostic that uses future data and is not a tradable rescaling.") |
| lines.append(r"\end{table}") |
| return "\n".join(lines) + "\n" |
|
|
|
|
| def country_table(preds: pd.DataFrame, model: str) -> tuple[str, pd.DataFrame]: |
| """R^2 vs the shrinkage mean and CW t by country, EM-trained vs DM-trained, for one model.""" |
| out = [] |
| for c, g in preds[preds["model"] == model].groupby("country"): |
| row = {"country": c} |
| for s in ("own", "dm_only"): |
| h = g[g["scope"] == s] |
| y, p, b = h["target"].to_numpy(), h["pred"].to_numpy(), h["shrink_mean"].to_numpy() |
| row[f"r2_{s}"] = 100 * (1 - np.sum((y - p) ** 2) / np.sum((y - b) ** 2)) |
| cw = pd.Series(2 * (y - b) * (p - b)).groupby(h["target_month"].to_numpy()).mean().to_numpy() |
| row[f"t_{s}"] = newey_west_t(cw, 3)[0] |
| row["obs"] = len(h) |
| out.append(row) |
| df = pd.DataFrame(out) |
| df["name"] = df["country"].map(COUNTRY) |
| df = df.sort_values("name").reset_index(drop=True) |
| lines = [r"\begin{table}[!ht]", r"\centering\small", |
| rf"\caption{{Transfer by country: {MODEL_LABEL[model].lower()} trained on emerging vs.\ developed markets}}", |
| r"\label{tab:country}", r"\begin{tabular}{lrrrrr}", r"\toprule", |
| r" & \multicolumn{2}{c}{EM-trained} & \multicolumn{2}{c}{DM-trained} & \\", |
| r"\cmidrule(lr){2-3}\cmidrule(lr){4-5}", |
| r"Market & $R^2_{OS}$ (\%) & CW $t$ & $R^2_{OS}$ (\%) & CW $t$ & Obs. \\", r"\midrule"] |
| for _, r in df.iterrows(): |
| lines.append(f"{r['name']} & {_f(r['r2_own'], 3)} & {_f(r['t_own'])} & {_f(r['r2_dm_only'], 3)} & " |
| f"{_f(r['t_dm_only'])} & {int(r['obs']):,} \\\\") |
| n_pos = {s: int((df[f"r2_{s}"] > 0).sum()) for s in ("own", "dm_only")} |
| n_sig = {s: int((df[f"t_{s}"] > 1.645).sum()) for s in ("own", "dm_only")} |
| lines += [r"\midrule", |
| rf"Markets with $R^2_{{OS}}>0$ & \multicolumn{{2}}{{c}}{{{n_pos['own']} of {len(df)}}} & " |
| rf"\multicolumn{{2}}{{c}}{{{n_pos['dm_only']} of {len(df)}}} & \\", |
| rf"Markets with CW $t>1.645$ & \multicolumn{{2}}{{c}}{{{n_sig['own']} of {len(df)}}} & " |
| rf"\multicolumn{{2}}{{c}}{{{n_sig['dm_only']} of {len(df)}}} & \\", |
| r"\bottomrule", r"\end{tabular}"] |
| lines += _notes( |
| "$R^2_{OS}$ and Clark--West $t$ against the shrinkage mean, computed within each market on the same " |
| "observations for both training scopes. Country-level tests are not adjusted for multiple comparisons.") |
| lines.append(r"\end{table}") |
| return "\n".join(lines) + "\n", df |
|
|
|
|
| def portfolio_table(port: pd.DataFrame, manifest: dict) -> str: |
| def label(s: str) -> str: |
| if s == "static_ew": |
| return "Static equal-weight", "--" |
| m, sc = s.split(":") |
| return MODEL_LABEL[m], SCOPE_LABEL[sc] |
|
|
| order = ["static_ew"] + [f"{m}:{s}" for m in LEARNED_ORDER for s in SCOPE_ORDER] + \ |
| ["shrink_mean:rule", "hist_mean:rule", "fmom:rule"] |
| port = port.set_index("strategy") |
| lines = [r"\begin{table}[!ht]", r"\centering\small\setlength{\tabcolsep}{5pt}", |
| r"\caption{Emerging-market factor-timing portfolios}", r"\label{tab:portfolios}", |
| r"\begin{tabular}{llrrrrr}", r"\toprule", |
| r"Strategy & Training & Mean (\%) & Vol.\ (\%) & SR gross & SR net & Turnover \\", r"\midrule"] |
| prev = None |
| for s in order: |
| if s not in port.index: |
| continue |
| r = port.loc[s] |
| name, sc = label(s) |
| if s == "fmom:rule": |
| name = "Factor momentum (sign)" |
| if s == "shrink_mean:rule": |
| lines.append(r"\addlinespace") |
| if sc == "EM" and prev is not None: |
| lines.append(r"\addlinespace[2pt]") |
| shown = "" if (name == prev and sc != "--") else name |
| prev = name |
| name = shown |
| lines.append(f"{name} & {sc} & {_f(r['mean_ann_pct'])} & {_f(r['vol_ann_pct'])} & " |
| f"{_f(r['sharpe_gross'])} & {_f(r['sharpe_net'])} & {_f(r['turnover_monthly'])} \\\\") |
| if s == "static_ew": |
| lines.append(r"\addlinespace") |
| prev = None |
| lines += [r"\bottomrule", r"\end{tabular}"] |
| lines += _notes( |
| "Within each emerging market and month, the timing portfolio holds each factor in proportion to its " |
| "forecast, scaled to unit gross exposure; the static portfolio holds every available factor equally. " |
| "Country portfolios are averaged with equal weights. Mean and volatility are annualized, gross of " |
| f"timing costs. Net Sharpe ratios deduct {manifest['cost_bps']:.0f} basis points per unit of monthly " |
| "turnover; factor returns are already gross of their own rebalancing costs. The factor-momentum rule " |
| "holds each factor long or short by the sign of its trailing 12-month mean.") |
| lines.append(r"\end{table}") |
| return "\n".join(lines) + "\n" |
|
|
|
|
| OTHER_NAMES = {"arg": "Argentina", "jor": "Jordan", "mar": "Morocco", "pak": "Pakistan", "rus": "Russia", |
| "ven": "Venezuela"} |
|
|
|
|
| def classification_table(path: Path) -> str: |
| """Appendix table of the reclassification events in config/market_history.yaml.""" |
| import yaml |
|
|
| ev = pd.DataFrame(yaml.safe_load(path.read_text())["events"]).sort_values(["from_month", "country"]) |
| names = {**COUNTRY, **OTHER_NAMES} |
| lab = {"DM": "Developed", "EM": "Emerging", "OTHER": "Frontier/standalone"} |
| lines = [r"\begin{table}[!ht]", r"\centering\footnotesize\setlength{\tabcolsep}{4pt}", |
| r"\caption{MSCI reclassifications used for the time-varying classification}", |
| r"\label{tab:classification}", r"\begin{tabular}{llll}", r"\toprule", |
| r"Market & In force from & New class & MSCI event \\", r"\midrule"] |
| for _, e in ev.iterrows(): |
| note = e["note"].replace("->", r"$\to$") |
| lines.append(f"{names[e['country']]} & {e['from_month']} & {lab[e['region']]} & {note} \\\\") |
| lines += [r"\bottomrule", r"\end{tabular}"] |
| lines += _notes( |
| "Each market takes the new class from the first full month after MSCI implemented the change; before " |
| "its first event a market has its prior class, and markets without events keep their current class. " |
| "First inclusion in the MSCI indexes and partial-inclusion steps are not modelled. Sources: MSCI's " |
| "list of market reclassifications and MSCI announcements, cited in \\texttt{config/market\\_history.yaml}.") |
| lines.append(r"\end{table}") |
| return "\n".join(lines) + "\n" |
|
|
|
|
| def strategy_label(s: str) -> str: |
| if s == "static_ew": |
| return "Static equal-weight" |
| m, sc = s.split(":") |
| return MODEL_LABEL[m] if sc == "rule" else f"{MODEL_LABEL[m]} ({SCOPE_LABEL[sc]}-trained)" |
|
|
|
|
| def cumulative_figure(monthly: pd.DataFrame, port: pd.DataFrame, path: Path, cost_bps: float) -> None: |
| """Same selection rule as the run report (static + the three best net Sharpe ratios), readable labels.""" |
| import matplotlib |
|
|
| matplotlib.use("Agg") |
| import matplotlib.pyplot as plt |
|
|
| best = port[port["strategy"] != "static_ew"].sort_values("sharpe_net", ascending=False)["strategy"].head(3) |
| fig, ax = plt.subplots(figsize=(7.5, 4)) |
| for st in ["static_ew", *best]: |
| g = monthly[monthly["strategy"] == st].sort_values("target_month") |
| x = pd.PeriodIndex(g["target_month"].astype(str), freq="M").to_timestamp() |
| ax.plot(x, 100 * np.cumsum(g["net"].to_numpy()), label=strategy_label(st), linewidth=1.4) |
| ax.axhline(0, color="0.6", linewidth=0.8) |
| ax.set_ylabel(f"Cumulative net return, % (net of {cost_bps:.0f} bp per unit turnover)", fontsize=8) |
| ax.legend(fontsize=8, frameon=False) |
| ax.spines[["top", "right"]].set_visible(False) |
| fig.tight_layout() |
| fig.savefig(path, dpi=200) |
| plt.close(fig) |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--run", default="reports/jkp_em") |
| ap.add_argument("--out", default="paper/tables") |
| ap.add_argument("--country-model", default=None, |
| help="default: the learned model with the highest R2 vs the shrinkage mean (same rule as the CLI)") |
| a = ap.parse_args() |
| run, out = Path(a.run), Path(a.out) |
| out.mkdir(parents=True, exist_ok=True) |
| manifest = json.loads((run / "run_manifest.json").read_text()) |
| if manifest.get("provenance") != "JKP": |
| raise SystemExit(f"{run} is not a real-data run (provenance={manifest.get('provenance')})") |
| preds = pd.read_parquet(run / "predictions.parquet") |
| manifest["last_year"] = int(preds["target_month"].max().year) if hasattr(preds["target_month"].iloc[0], "year") \ |
| else int(str(preds["target_month"].max())[:4]) |
|
|
| (out / "coverage.tex").write_text(coverage_table(pd.read_csv(run / "coverage.csv"), manifest)) |
| slopes = forecast_slopes(preds) |
| slopes.to_csv(run / "forecast_slopes.csv", index=False) |
| (out / "r2_oos.tex").write_text(r2_table(pd.read_csv(run / "r2_oos.csv"), manifest, slopes)) |
|
|
| r2 = pd.read_csv(run / "r2_oos.csv") |
| model = a.country_model or r2[r2["model"].isin(LEARNED_ORDER)].iloc[0]["model"] |
| tex, by_country = country_table(preds, model) |
| (out / "transfer_by_country.tex").write_text(tex) |
| by_country.to_csv(run / f"transfer_by_country_{model}.csv", index=False) |
| (out / "portfolios.tex").write_text(portfolio_table(pd.read_csv(run / "portfolios.csv"), manifest)) |
| (out / "market_history.tex").write_text( |
| classification_table(Path(__file__).resolve().parents[1] / "config" / "market_history.yaml")) |
| fig_dir = out.parent / "figures" |
| fig_dir.mkdir(exist_ok=True) |
| cumulative_figure(pd.read_csv(run / "portfolio_monthly.csv"), pd.read_csv(run / "portfolios.csv"), |
| fig_dir / "cumulative_net.png", manifest["cost_bps"]) |
| print(f"wrote tables to {out} and figure to {fig_dir}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
