hrt / sim /core.py
dejanb's picture
Code, frozen data, and outputs for the paper
28673f9 verified
Raw History Blame Contribute Delete
17.4 kB
"""Models, strategies, accounting and statistical tests for the HRT paradox paper.
Strategies decide a position w_t in [0, 1] (long or cash, no leverage) at the close of
day t, using only data up to t; the position earns the return of day t+1, minus costs.
hold buy and hold
sma trend baseline: long when SMA(50) > SMA(200)
bayes Bayesian drift: P(mu > 0 | data) from a discounted Normal-Inverse-Gamma model
mc one-step Bayesian Monte Carlo planning: sample 20-day futures from the posterior,
pick the position with the highest expected CRRA utility net of trading costs
mcts Bayes-adaptive Monte Carlo tree search: same model and utility, but the agent
can rebalance every 5 days within the 20-day horizon, reacting to whether the
price went down, sideways or up (UCT with root sampling and common random
numbers at the root)
tree the same 4-step decision tree searched exhaustively by backward induction on a
fixed scenario set (the limit that MCTS approximates)
All hyperparameters are fixed here, before any run on the data they are applied to.
"""
import math
from pathlib import Path
import numpy as np
import pandas as pd
from scipy import stats
ROOT = Path(__file__).resolve().parent.parent
DATA, FIG, OUT = ROOT / "data", ROOT / "fig", ROOT / "out"
# periods per year, evaluation window ("five months"), cost per unit of turnover,
# prior daily volatility, warm-up length
CRYPTO = dict(ppy=365, window=152, cost=0.0015, s0=0.04, warmup=365, cls="crypto")
ETF = dict(ppy=252, window=105, cost=0.0005, s0=0.012, warmup=252, cls="etf")
ASSETS = dict(btc=CRYPTO, eth=CRYPTO, bnb=CRYPTO, xrp=CRYPTO, ltc=CRYPTO, ada=CRYPTO,
spy=ETF, qqq=ETF, gld=ETF, tlt=ETF)
HALF_LIFE = 90 # discounting of old data, in observations
ENTER, EXIT = 0.55, 0.45
KAPPA0, ALPHA0 = 10.0, 2.0
MC_PATHS, MC_HORIZON, GAMMA = 2000, 20, 3.0
MC_GRID = [0.0, 0.25, 0.5, 0.75, 1.0]
TREE_SIMS, TREE_STEP, TREE_DEPTH, UCT_C = 1600, 5, 4, 1.0 # 4 decisions x 5 days = 20
N_SHIFTS = 5000
SEED = 2026
LABEL = dict(hold="Buy and hold", sma="SMA 50/200", bayes="Bayesian drift",
mc="Bayesian MC (1 step)", tree="Bayesian tree (4 steps)", mcts="Bayes-adaptive MCTS", vol="Volatility timing",
const="Constant mix")
def load(name):
df = pd.read_csv(DATA / f"{name}.csv", parse_dates=["date"]).set_index("date")
return df["close"]
def log_returns(price):
return np.log(price).diff().fillna(0.0).to_numpy()
def rf_daily(dates, ppy):
"""Risk-free rate per period on the given dates: 13-week US Treasury bill yield
(Yahoo ^IRX, annual percent), carried forward to days without a quote."""
y = load("irx")
y = y.reindex(y.index.union(pd.DatetimeIndex(dates))).ffill().bfill()
y = y.reindex(pd.DatetimeIndex(dates)).to_numpy()
return (1.0 + y / 100.0) ** (1.0 / ppy) - 1.0
# ---------- Bayesian model ----------
def posterior_path(r, s0, half_life=HALF_LIFE, kappa0=KAPPA0):
"""Discounted NIG posterior after each day: columns mu_n, kappa_n, alpha_n, beta_n."""
d = 0.5 ** (1.0 / half_life)
b0 = ALPHA0 * s0 * s0
n = s1 = s2 = 0.0
out = np.empty((len(r), 4))
for t, x in enumerate(r):
n, s1, s2 = d * n + 1.0, d * s1 + x, d * s2 + x * x
kn = kappa0 + n
xbar = s1 / n
out[t, 0] = s1 / kn # prior mean is zero
out[t, 1] = kn
out[t, 2] = ALPHA0 + n / 2.0
out[t, 3] = b0 + 0.5 * max(s2 - s1 * s1 / n, 0.0) + kappa0 * n * xbar * xbar / (2.0 * kn)
return out
def prob_positive(post):
mn, kn, an, bn = post.T
return stats.t.cdf(mn / np.sqrt(bn / (an * kn)), df=2.0 * an)
def predictive_vol(post):
"""Posterior mean of sigma (daily)."""
return np.sqrt(post[:, 3] / np.maximum(post[:, 2] - 1.0, 0.5))
# ---------- strategies ----------
def sma_weights(price):
fast, slow = price.rolling(50).mean(), price.rolling(200).mean()
return (fast > slow).astype(float).to_numpy()
def bayes_weights(post, enter=ENTER, exit_=None):
exit_ = 1.0 - enter if exit_ is None else exit_
p = prob_positive(post)
w, cur = np.zeros(len(p)), 0.0
for t in range(len(p)):
if cur == 0.0 and p[t] > enter:
cur = 1.0
elif cur == 1.0 and p[t] < exit_:
cur = 0.0
w[t] = cur
return w
def crra(wealth, gamma=GAMMA):
return (np.maximum(wealth, 1e-6) ** (1.0 - gamma) - 1.0) / (1.0 - gamma)
def mc_weights(post, cost, seed, start=0, gamma=GAMMA):
rng = np.random.default_rng(seed)
grid = np.array(MC_GRID)
w, cur = np.zeros(len(post)), 0.0
for t in range(start, len(post)):
mn, kn, an, bn = post[t]
sig2 = bn / rng.gamma(an, 1.0, MC_PATHS) # sigma^2 ~ InvGamma
mu = mn + np.sqrt(sig2 / kn) * rng.standard_normal(MC_PATHS)
R = MC_HORIZON * mu + np.sqrt(MC_HORIZON * sig2) * rng.standard_normal(MC_PATHS)
wealth = 1.0 + grid[None, :] * np.expm1(R)[:, None] - cost * np.abs(grid - cur)[None, :]
cur = grid[np.argmax(crra(wealth, gamma).mean(axis=0))]
w[t] = cur
return w
def mcts_decide(post_t, cur, cost, sims, rng):
"""One decision of Bayes-adaptive MCTS (root sampling, as in BAMCP).
Each scenario draws a market (mu, sigma^2) from the posterior and a 20-day price
path from it. Tree nodes are histories of (action, observed move), where the move
over each 5-day step is bucketed into down / sideways / up, so later decisions can
react to what the simulated market did. Below the root, actions are chosen by UCT;
a history seen for the first time is added to the tree and the episode is finished
with the default policy (keep the position). At the root, every scenario is played
once for each action (common random numbers), which removes most sampling noise
from the comparison of root actions. `sims` counts episodes."""
mn, kn, an, bn = post_t
n_act, n_scen = len(MC_GRID), sims // len(MC_GRID)
sig2 = bn / rng.gamma(an, 1.0, n_scen)
mu = mn + np.sqrt(sig2 / kn) * rng.standard_normal(n_scen)
R = TREE_STEP * mu[:, None] + np.sqrt(TREE_STEP * sig2)[:, None] * \
rng.standard_normal((n_scen, TREE_DEPTH))
thr = 0.5 * math.sqrt(TREE_STEP * bn / max(an - 1.0, 0.5))
bucket = np.where(R < -thr, 0, np.where(R > thr, 2, 1)).tolist()
gross = np.expm1(R).tolist()
tree, one_g = {}, 1.0 - GAMMA
root_tot = [0.0] * n_act
su = suu = 0.0
k = 0
for s in range(n_scen):
g_s, b_s = gross[s], bucket[s]
c = UCT_C * math.sqrt(max(suu / k - (su / k) ** 2, 1e-12)) if k > 10 else 0.1
for a0 in range(n_act):
w_prev = MC_GRID[a0]
wealth = 1.0 + w_prev * g_s[0] - cost * abs(w_prev - cur)
h, path = a0 * 3 + b_s[0] + 1, []
for d in range(1, TREE_DEPTH):
node = tree.get(h)
if node is None: # expansion, then default policy
node = tree[h] = ([0] * n_act, [0.0] * n_act)
path.append((node[0], node[1], MC_GRID.index(w_prev)))
for dd in range(d, TREE_DEPTH):
wealth *= 1.0 + w_prev * g_s[dd]
break
cnt, tot = node
untried = [i for i in range(n_act) if cnt[i] == 0]
if untried: # nearest position first
a = min(untried, key=lambda i: abs(MC_GRID[i] - w_prev))
else:
logn = math.log(sum(cnt))
a, best = 0, -1e300
for i in range(n_act):
v = tot[i] / cnt[i] + c * math.sqrt(logn / cnt[i])
if v > best:
a, best = i, v
w = MC_GRID[a]
wealth *= 1.0 + w * g_s[d] - cost * abs(w - w_prev)
path.append((cnt, tot, a))
h = h * 16 + a * 3 + b_s[d] + 1
w_prev = w
u = (max(wealth, 1e-6) ** one_g - 1.0) / one_g
root_tot[a0] += u
su += u
suu += u * u
k += 1
for cnt, tot, a in path:
cnt[a] += 1
tot[a] += u
return MC_GRID[max(range(n_act), key=root_tot.__getitem__)]
def mcts_weights(post, cost, seed, start=0, sims=TREE_SIMS):
rng = np.random.default_rng(seed)
w, cur = np.zeros(len(post)), 0.0
for t in range(start, len(post)):
cur = mcts_decide(post[t], cur, cost, sims, rng)
w[t] = cur
return w
def tree_weights(post, cost, seed, start=0):
"""Exhaustive search of the same 4-step decision tree by backward induction on a
fixed set of sampled scenarios (the limit that MCTS approximates by sampling).
State before each decision: current position and the bucketed price history.
Every action sequence is evaluated on the same scenarios, so comparisons are paired."""
rng = np.random.default_rng(seed)
grid = np.array(MC_GRID)
n_act, one_g = len(grid), 1.0 - GAMMA
switch = np.abs(grid[None, :] - grid[:, None]) # [from, to]
w, cur = np.zeros(len(post)), 0
for t in range(start, len(post)):
mn, kn, an, bn = post[t]
sig2 = bn / rng.gamma(an, 1.0, MC_PATHS)
mu = mn + np.sqrt(sig2 / kn) * rng.standard_normal(MC_PATHS)
R = TREE_STEP * mu[:, None] + np.sqrt(TREE_STEP * sig2)[:, None] * \
rng.standard_normal((MC_PATHS, TREE_DEPTH))
thr = 0.5 * math.sqrt(TREE_STEP * bn / max(an - 1.0, 0.5))
bucket = np.where(R < -thr, 0, np.where(R > thr, 2, 1))
gross = np.expm1(R)
v = np.ones((MC_PATHS, n_act)) # value after the last step
for d in range(TREE_DEPTH - 1, -1, -1):
# f[n, from, to]: wealth factor of step d, raised to 1 - gamma
f = 1.0 + grid[None, None, :] * gross[:, d, None, None] - cost * switch[None]
q = np.maximum(f, 1e-6) ** one_g * v[:, None, :]
if d == 0:
cur = int(np.argmin(q[:, cur, :].mean(axis=0))) # gamma > 1: minimize
break
code = np.zeros(MC_PATHS, dtype=int) # history of moves before d
for j in range(d):
code = code * 3 + bucket[:, j]
onehot = np.zeros((MC_PATHS, 3 ** d))
onehot[np.arange(MC_PATHS), code] = 1.0
sums = onehot.T @ q.reshape(MC_PATHS, -1) # [group, from * to]
best = sums.reshape(-1, n_act, n_act).argmin(axis=2) # [group, from]
v = np.take_along_axis(q, best[code][:, :, None], axis=2)[:, :, 0]
w[t] = grid[cur]
return w
def vol_weights(post, target):
"""Volatility timing without any view on direction: w = min(1, target / sigma_hat)."""
return np.minimum(1.0, target / predictive_vol(post))
def match_exposure(post, sl, exposure):
"""Target volatility for which vol_weights has the given mean exposure on slice sl."""
lo, hi = 1e-5, 1.0
for _ in range(60):
mid = 0.5 * (lo + hi)
if vol_weights(post, mid)[sl].mean() < exposure:
lo = mid
else:
hi = mid
return 0.5 * (lo + hi)
# ---------- accounting ----------
def net_returns(w, r_next, cost, rf=0.0):
"""w[t] earns the simple return of day t+1, the cash part 1 - w[t] earns the
risk-free rate rf; cost is paid on changes of position. Returns total returns."""
turn = np.abs(np.diff(np.concatenate([[0.0], w])))
return w * np.expm1(r_next) + (1.0 - w) * rf - cost * turn
def sharpe(ret, ppy):
s = ret.std()
return float(ret.mean() / s * math.sqrt(ppy)) if s > 0 else 0.0
def metrics(ret, w, ppy, rf=0.0):
"""ret: total returns; the Sharpe ratio is computed on returns in excess of rf."""
eq = np.cumprod(1.0 + ret)
years = len(ret) / ppy
dd = 1.0 - eq / np.maximum.accumulate(eq)
return dict(
total=float(eq[-1] - 1.0),
cagr=float(eq[-1] ** (1 / years) - 1.0),
vol=float(ret.std() * math.sqrt(ppy)),
sharpe=sharpe(ret - rf, ppy),
maxdd=float(dd.max()),
exposure=float(w.mean()),
trades_per_year=float((np.abs(np.diff(w)) > 0).sum() / years),
)
def window_returns(ret, n):
eq = np.concatenate([[1.0], np.cumprod(1.0 + ret)])
return eq[n:] / eq[:-n] - 1.0
# ---------- statistical tests ----------
def shift_test(w, r_next, cost, ppy, window, rng, n_shifts=N_SHIFTS, rf=0.0):
"""Random-timing benchmark: circularly shift the position series against returns.
Keeps exposure, turnover and holding periods; destroys any timing skill."""
n, base = len(w), sharpe(net_returns(w, r_next, cost, rf) - rf, ppy)
sh, win = np.empty(n_shifts), np.empty(n_shifts)
for i, k in enumerate(rng.integers(window, n - window, n_shifts)):
ret = net_returns(np.roll(w, k), r_next, cost, rf)
sh[i] = sharpe(ret - rf, ppy)
win[i] = (window_returns(ret, window) > 0).mean()
return dict(p_value=float((1 + (sh >= base).sum()) / (1 + n_shifts)),
shift_sharpe_median=float(np.median(sh)),
shift_win_frac_median=float(np.median(win)))
def stationary_bootstrap_idx(n, mean_block, rng):
new = rng.random(n) < 1.0 / mean_block
new[0] = True
start_pos = np.maximum.accumulate(np.where(new, np.arange(n), 0))
starts = rng.integers(0, n, n)
return (starts[start_pos] + np.arange(n) - start_pos) % n
def bootstrap_sharpe_diff(ret_a, ret_b, ppy, rng, n_boot=2000, mean_block=20):
"""Paired stationary bootstrap of Sharpe(a) - Sharpe(b)."""
n, diffs = len(ret_a), np.empty(n_boot)
for i in range(n_boot):
idx = stationary_bootstrap_idx(n, mean_block, rng)
diffs[i] = sharpe(ret_a[idx], ppy) - sharpe(ret_b[idx], ppy)
lo, hi = np.percentile(diffs, [2.5, 97.5])
return dict(diff=sharpe(ret_a, ppy) - sharpe(ret_b, ppy), lo=float(lo), hi=float(hi),
p_le0=float((diffs <= 0).mean()))
def spa_sharpe(ex, bench, ppy, rng, n_boot=2000, mean_block=20):
"""Hansen's (2005) test for superior predictive ability, applied to Sharpe-ratio
differences against a benchmark. ex: [T, K] excess returns of K strategies;
bench: [T] excess returns of the benchmark. H0: no strategy has a higher Sharpe
ratio than the benchmark. Studentized with bootstrap standard errors; returns the
consistent p-value (SPA_c) and White's reality-check p-value (no studentization,
least favorable recentering)."""
T, K = ex.shape
def sr(x):
return x.mean(axis=0) / x.std(axis=0) * math.sqrt(ppy)
d = sr(ex) - sr(bench[:, None])
boot = np.empty((n_boot, K))
for b in range(n_boot):
idx = stationary_bootstrap_idx(T, mean_block, rng)
boot[b] = sr(ex[idx]) - sr(bench[idx][:, None])
se = np.maximum(boot.std(axis=0), 1e-12)
stat = max(float((d / se).max()), 0.0)
keep = d / se >= -math.sqrt(2.0 * math.log(math.log(T)))
cen = boot - np.where(keep, d, 0.0) # SPA_c recentering
p_spa = float((np.maximum((cen / se).max(axis=1), 0.0) >= stat).mean())
rc_stat = float(d.max())
p_rc = float(((boot - d).max(axis=1) >= rc_stat).mean())
return dict(p_spa=p_spa, p_rc=p_rc, best=int(np.argmax(d)), best_diff=float(d.max()), k=K)
def pbo_cscv(ex, n_blocks=16):
"""Probability of backtest overfitting by combinatorially symmetric cross-validation
(Bailey et al. 2017). ex: [T, N] excess returns of N variants. For every split of
the n_blocks blocks into two halves, the variant with the best in-sample Sharpe
ratio is ranked out of sample; PBO is the share of splits in which it falls in the
bottom half."""
from itertools import combinations
T, N = ex.shape
L = T // n_blocks
x = ex[:L * n_blocks].reshape(n_blocks, L, N)
s1, s2 = x.sum(axis=1), (x * x).sum(axis=1) # [blocks, N]
logits, oos_best = [], []
for c in combinations(range(n_blocks), n_blocks // 2):
m = np.zeros(n_blocks, dtype=bool)
m[list(c)] = True
def sr(mask):
n = mask.sum() * L
mu = s1[mask].sum(axis=0) / n
return mu / np.sqrt(np.maximum(s2[mask].sum(axis=0) / n - mu * mu, 1e-18))
is_, oos = sr(m), sr(~m)
best = int(np.argmax(is_))
omega = (stats.rankdata(oos)[best]) / (N + 1)
logits.append(math.log(omega / (1 - omega)))
logits = np.array(logits)
return dict(pbo=float((logits <= 0).mean()), n_splits=len(logits), n_variants=N)
def psr(ret, sr_star=0.0):
"""Probabilistic Sharpe ratio (Bailey and Lopez de Prado); sr_star per period."""
n, sr = len(ret), ret.mean() / ret.std()
g3, g4 = stats.skew(ret), stats.kurtosis(ret, fisher=False)
den = math.sqrt(max(1.0 - g3 * sr + (g4 - 1.0) / 4.0 * sr * sr, 1e-12))
return float(stats.norm.cdf((sr - sr_star) * math.sqrt(n - 1) / den))
def deflated_sr_threshold(trial_sharpes_per_period):
"""Expected maximum per-period Sharpe among N unskilled trials."""
n, v = len(trial_sharpes_per_period), np.var(trial_sharpes_per_period, ddof=1)
em = 0.5772156649
z = (1 - em) * stats.norm.ppf(1 - 1.0 / n) + em * stats.norm.ppf(1 - 1.0 / (n * math.e))
return float(math.sqrt(v) * z)