| """Load Jensen-Kelly-Pedersen (JKP) global factor returns, or generate a synthetic panel. |
| |
| Two input layouts are accepted and normalised to one long table: |
| |
| * jkpfactors.com download: location, name, freq, weighting, direction, |
| n_stocks, n_stocks_min, date, ret |
| * JKP code output (internal): excntry, characteristic, direction, date, |
| ret_ew, ret_vw, ret_vw_cap, n_stocks_min |
| |
| Output columns: country, factor, month (pandas Period[M]), ret, region |
| Returns are decimal excess returns (0.01 = 1%). JKP factors are already signed so |
| that the long leg is the side the original paper predicts to earn more. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import glob |
| import io |
| import logging |
| import zipfile |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| import yaml |
|
|
| log = logging.getLogger(__name__) |
|
|
| ROOT = Path(__file__).resolve().parents[2] |
| MARKETS_FILE = ROOT / "config" / "markets.yaml" |
|
|
| _COUNTRY_COLS = ("location", "excntry", "country") |
| _FACTOR_COLS = ("name", "characteristic", "factor") |
| _DATE_COLS = ("date", "eom", "month") |
|
|
|
|
| @dataclass(frozen=True) |
| class Markets: |
| developed: frozenset[str] |
| emerging: frozenset[str] |
|
|
| def region(self, country: str) -> str: |
| if country in self.developed: |
| return "DM" |
| if country in self.emerging: |
| return "EM" |
| return "OTHER" |
|
|
|
|
| def load_markets(path: Path = MARKETS_FILE) -> Markets: |
| cfg = yaml.safe_load(path.read_text()) |
| return Markets(frozenset(cfg["developed"]), frozenset(cfg["emerging"])) |
|
|
|
|
| MACRO_FEATURES = ["mac_vix", "mac_term", "mac_usd12"] |
|
|
|
|
| def load_macro(directory: str | Path) -> pd.DataFrame: |
| """Monthly U.S. state variables from FRED CSVs (fredgraph.csv layout), indexed by Period[M]. |
| |
| mac_vix log of the last VIX close in the month (VIXCLS, from 1990) |
| mac_term last 10-year minus 3-month Treasury spread in the month (T10Y3M, percent) |
| mac_usd12 12-month log change of the broad trade-weighted dollar: the discontinued |
| monthly TWEXBMTH through 2005-12, then the monthly average of DTWEXBGS, |
| level-spliced at 2006-01 (the two indexes differ in coverage) |
| Every value dated t is observable at the end of month t. |
| """ |
| d = Path(directory) |
|
|
| def series(name: str) -> pd.Series: |
| f = pd.read_csv(d / f"{name}.csv") |
| s = pd.to_numeric(f.iloc[:, 1], errors="coerce") |
| s.index = pd.to_datetime(f.iloc[:, 0]).dt.to_period("M") |
| return s.dropna() |
|
|
| vix = series("VIXCLS").groupby(level=0).last() |
| term = series("T10Y3M").groupby(level=0).last() |
| old = np.log(series("TWEXBMTH").groupby(level=0).mean()) |
| new = np.log(series("DTWEXBGS").groupby(level=0).mean()) |
| splice = pd.Period("2006-01", freq="M") |
| if splice not in old.index or splice not in new.index: |
| raise ValueError("TWEXBMTH and DTWEXBGS must both cover 2006-01 to splice the dollar index") |
| usd = pd.concat([old[old.index < splice], new[new.index >= splice] + old[splice] - new[splice]]) |
| usd = usd.reindex(pd.period_range(usd.index.min(), usd.index.max(), freq="M")) |
| out = pd.DataFrame({"mac_vix": np.log(vix), "mac_term": term, "mac_usd12": usd - usd.shift(12)}) |
| out.index.name = "month" |
| return out |
|
|
|
|
| MARKET_HISTORY_FILE = ROOT / "config" / "market_history.yaml" |
|
|
|
|
| def apply_market_history( |
| panel: pd.DataFrame, markets: Markets | None = None, path: Path = MARKET_HISTORY_FILE |
| ) -> pd.DataFrame: |
| """Replace the static region with the region in force in each month (see market_history.yaml).""" |
| markets = markets or load_markets() |
| events = pd.DataFrame(yaml.safe_load(Path(path).read_text())["events"]) |
| events["from_month"] = pd.PeriodIndex(events["from_month"].astype(str), freq="M") |
| events = events.sort_values(["country", "from_month"]) |
| out = panel.copy() |
| for country, ev in events.groupby("country"): |
| if ev.iloc[-1]["region"] != markets.region(country): |
| raise ValueError(f"{country}: last event region {ev.iloc[-1]['region']} " |
| f"differs from markets.yaml ({markets.region(country)})") |
| rows = out["country"] == country |
| if not rows.any(): |
| continue |
| month = out.loc[rows, "month"] |
| region = pd.Series(ev.iloc[0]["was"], index=month.index) |
| for _, e in ev.iterrows(): |
| region[month >= e["from_month"]] = e["region"] |
| out.loc[rows, "region"] = region |
| return out |
|
|
|
|
| def _read_any(path: str | Path) -> pd.DataFrame: |
| """Read one CSV, every CSV or .zip in a directory/glob, or every CSV inside a .zip.""" |
| p = Path(path) |
| frames: list[pd.DataFrame] = [] |
| if p.is_dir(): |
| files = sorted(f for f in p.iterdir() if f.suffix.lower() in (".csv", ".zip")) |
| elif any(ch in str(path) for ch in "*?["): |
| files = [Path(f) for f in sorted(glob.glob(str(path)))] |
| else: |
| files = [p] |
| if not files: |
| raise FileNotFoundError(f"No CSV files found at {path}") |
| for f in files: |
| if f.suffix.lower() == ".zip": |
| with zipfile.ZipFile(f) as z: |
| for name in sorted(n for n in z.namelist() if n.lower().endswith(".csv")): |
| frames.append(pd.read_csv(io.BytesIO(z.read(name)))) |
| else: |
| frames.append(pd.read_csv(f)) |
| return pd.concat(frames, ignore_index=True) |
|
|
|
|
| def _pick(cols: pd.Index, candidates: tuple[str, ...], what: str) -> str: |
| for c in candidates: |
| if c in cols: |
| return c |
| raise ValueError(f"Cannot find a {what} column; expected one of {candidates}, got {list(cols)}") |
|
|
|
|
| def normalise( |
| raw: pd.DataFrame, |
| weighting: str = "vw_cap", |
| min_stocks: int = 5, |
| markets: Markets | None = None, |
| ) -> pd.DataFrame: |
| """Map either JKP layout to the canonical long table and validate it.""" |
| markets = markets or load_markets() |
| cols = raw.columns |
| c_country = _pick(cols, _COUNTRY_COLS, "country") |
| c_factor = _pick(cols, _FACTOR_COLS, "factor") |
| c_date = _pick(cols, _DATE_COLS, "date") |
|
|
| if "ret" in cols: |
| c_ret = "ret" |
| if "weighting" in cols: |
| kept = raw["weighting"].astype(str).str.lower().unique() |
| if len(kept) > 1: |
| raw = raw[raw["weighting"].astype(str).str.lower() == weighting] |
| log.info("Kept weighting=%s out of %s", weighting, list(kept)) |
| else: |
| c_ret = f"ret_{weighting}" |
| if c_ret not in cols: |
| raise ValueError(f"No 'ret' or '{c_ret}' column in input") |
|
|
| df = pd.DataFrame( |
| { |
| "country": raw[c_country].astype(str).str.lower().str.strip(), |
| "factor": raw[c_factor].astype(str).str.strip(), |
| "month": pd.to_datetime(raw[c_date]).dt.to_period("M"), |
| "ret": pd.to_numeric(raw[c_ret], errors="coerce"), |
| } |
| ) |
| if "n_stocks_min" in cols and min_stocks > 0: |
| n = pd.to_numeric(raw["n_stocks_min"], errors="coerce") |
| before = len(df) |
| df = df[(n >= min_stocks).to_numpy()] |
| log.info("Dropped %d rows with n_stocks_min < %d", before - len(df), min_stocks) |
|
|
| df = df.dropna(subset=["ret"]) |
|
|
| |
| |
| if df["ret"].abs().median() > 0.2: |
| raise ValueError( |
| "Returns look like percentages (median |ret| > 0.2). " |
| "Pass decimal returns or divide by 100 before loading." |
| ) |
|
|
| dup = df.duplicated(["country", "factor", "month"]) |
| if dup.any(): |
| raise ValueError(f"{int(dup.sum())} duplicate country-factor-month rows") |
|
|
| df["region"] = df["country"].map(markets.region) |
| return df.sort_values(["country", "factor", "month"]).reset_index(drop=True) |
|
|
|
|
| def load_jkp(path: str | Path, **kwargs) -> pd.DataFrame: |
| return normalise(_read_any(path), **kwargs) |
|
|
|
|
| def coverage(df: pd.DataFrame) -> pd.DataFrame: |
| """One row per country: region, factors, first and last month, months.""" |
| g = df.groupby(["region", "country"]) |
| out = g.agg( |
| factors=("factor", "nunique"), |
| first=("month", "min"), |
| last=("month", "max"), |
| months=("month", "nunique"), |
| obs=("ret", "size"), |
| ) |
| return out.reset_index().sort_values(["region", "country"]) |
|
|
|
|
| |
| |
| |
|
|
|
|
| def synthetic_panel( |
| n_dm: int = 8, |
| n_em: int = 8, |
| n_factors: int = 20, |
| n_months: int = 360, |
| signal_sd: float = 0.004, |
| noise_sd: float = 0.03, |
| phi: float = 0.95, |
| global_share: float = 0.6, |
| premium: float = 0.002, |
| premium_sd: float = 0.003, |
| seed: int = 0, |
| ) -> tuple[pd.DataFrame, pd.DataFrame]: |
| """Returns (panel, truth). |
| |
| r[c,f,t+1] = mu[c,f] + x[c,f,t] + e[c,f,t+1], mu[c,f] ~ N(premium, premium_sd) |
| x[c,f,t] = sqrt(global_share) * z[f,t] + sqrt(1 - global_share) * u[c,f,t] |
| z, u = independent AR(1) processes with persistence phi, sd signal_sd |
| |
| x is the predictable part. It is persistent, so trailing mean returns carry |
| information about it, and its global component z is shared across |
| countries, so developed-market history is informative about emerging markets. |
| Setting signal_sd = 0 gives a panel with no predictability at all. |
| """ |
| rng = np.random.default_rng(seed) |
| dm = [f"d{i:02d}" for i in range(n_dm)] |
| em = [f"e{i:02d}" for i in range(n_em)] |
| countries = dm + em |
| factors = [f"f{j:03d}" for j in range(n_factors)] |
| months = pd.period_range("1990-01", periods=n_months, freq="M") |
|
|
| def ar1(shape): |
| x = np.zeros(shape) |
| innov_sd = signal_sd * np.sqrt(1 - phi**2) |
| x[0] = rng.normal(0, signal_sd, shape[1:]) |
| for t in range(1, shape[0]): |
| x[t] = phi * x[t - 1] + rng.normal(0, innov_sd, shape[1:]) |
| return x |
|
|
| z = ar1((n_months, n_factors)) |
| u = ar1((n_months, len(countries), n_factors)) |
| x = np.sqrt(global_share) * z[:, None, :] + np.sqrt(1 - global_share) * u |
| e = rng.normal(0, noise_sd, (n_months, len(countries), n_factors)) |
| |
| |
| mu = rng.normal(premium, premium_sd, (len(countries), n_factors)) |
|
|
| r = np.full_like(x, np.nan) |
| r[1:] = mu + x[:-1] + e[1:] |
|
|
| idx = pd.MultiIndex.from_product([months, countries, factors], names=["month", "country", "factor"]) |
| panel = pd.DataFrame({"ret": r.reshape(-1)}, index=idx).reset_index().dropna() |
| panel["region"] = np.where(panel["country"].str.startswith("d"), "DM", "EM") |
| truth = pd.DataFrame( |
| {"true_expected_next": (mu[None, :, :] + x).reshape(-1)}, index=idx |
| ).reset_index() |
| return panel.sort_values(["country", "factor", "month"]).reset_index(drop=True), truth |
|
|
