Download sim/core.py from dejanb/hrt: direct link, hf CLI and curl.
- Browser
- Download file 17.4 kB
-
https://huggingface.co/datasets/dejanb/hrt/resolve/main/sim/core.py
- Command line
-
hf download hf://datasets/dejanb/hrt/sim/core.py
-
curl -L -o core.py https://huggingface.co/datasets/dejanb/hrt/resolve/main/sim/core.py
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) | |