be084b5154
Multi-strat with foxhunt's own ideas. (1) Combine uncorrelated premia: ~0.72 Sharpe 2019-26 but ~=60/40, only when streams net-positive (traditional 2010-26 combine +0.51 < equity +0.68 = dilution). (2) Edge-decay-trust allocation (Page-Hinkley theta, resurrection) genuinely helps: +0.16->+0.27, correctly down-weights decayed streams. (3) Static risk layer crushed returns (one-way latch); ADAPTIVE layer (continuous self-recovering DD de-lever + Kelly-floor + z-score corr + EMA vol) beat it (+0.03->+0.14, maxDD -18.7->-14.5) -- value is drawdown control. (4) THE MOAT = cheap financing: adaptive 1x Sharpe +0.48 vs 2x +0.14; retail 6-7% margin kills leverage benefit. Funds lever ~0.7 Sharpe only via prime-brokerage SOFR+1-2%. Deployable best = ~1x adaptive-risk-managed diversified book (~0.5-0.7 Sharpe, unlevered), scales with capital. Foxhunt ideas improve execution (validated); engine value = risk-mgmt not alpha. Ceiling ~0.7 ironclad. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
105 lines
4.7 KiB
Python
105 lines
4.7 KiB
Python
#!/usr/bin/env python3
|
|
"""Nano multi-strat: operate like a hedge fund. Combine uncorrelated premia (equity, bond, gold,
|
|
commodity, trend, crypto) risk-parity-weighted + vol-targeted; show the correlation matrix (the
|
|
diversification engine), combined Sharpe vs each piece alone, and how leverage scales the return.
|
|
|
|
Not market-neutral — it's the diversified-premia + leverage (All-Weather/alt-risk-premia) model.
|
|
The point: each stream is modest, but uncorrelated streams combine to a higher Sharpe, then leverage
|
|
turns modest Sharpe into real return. Risk management = the engine's actual job."""
|
|
import math
|
|
import os
|
|
import sys
|
|
|
|
import numpy as np
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
from signal_sweep import load_panel, build_returns # noqa: E402
|
|
import pit_sweep # noqa: E402
|
|
|
|
TV = 0.10
|
|
|
|
|
|
def vt(r, tv=TV, win=63, cap=4.0):
|
|
out = np.zeros_like(r)
|
|
for t in range(win, len(r)):
|
|
rv = np.std(r[t - win:t]) * math.sqrt(252)
|
|
out[t] = r[t] * min(cap, tv / (rv + 1e-9))
|
|
return out
|
|
|
|
|
|
def stats(r):
|
|
r = r[np.isfinite(r)]
|
|
if len(r) < 50 or r.std() == 0:
|
|
return (float("nan"),) * 4
|
|
ann = r.mean() * 252; vol = r.std() * math.sqrt(252)
|
|
eq = np.cumprod(1 + r); dd = float((eq / np.maximum.accumulate(eq) - 1).min())
|
|
return ann, vol, ann / vol, dd
|
|
|
|
|
|
def run(streams, days, year, label):
|
|
names = list(streams)
|
|
M = np.column_stack([vt(streams[n]) for n in names]) # each vol-normalized to 10%
|
|
T = M.shape[0]
|
|
print(f"\n===== {label} ({T} days) =====")
|
|
print(" standalone Sharpe: " + " ".join(f"{n}:{stats(streams[n])[2]:+.2f}" for n in names))
|
|
# correlation matrix of the (vol-normalized) streams
|
|
C = np.corrcoef(np.nan_to_num(M).T)
|
|
print(" correlation matrix:")
|
|
print(" " + " ".join(f"{n[:5]:>6}" for n in names))
|
|
for i, n in enumerate(names):
|
|
print(f" {n[:5]:>5} " + " ".join(f"{C[i, j]:>+6.2f}" for j in range(len(names))))
|
|
avg_corr = (C.sum() - len(names)) / (len(names) ** 2 - len(names))
|
|
# combined: equal-risk-weight then vol-target the bundle
|
|
combo = vt(np.nanmean(M, axis=1))
|
|
a, v, sh, dd = stats(combo)
|
|
best = max(stats(streams[n])[2] for n in names)
|
|
print(f" avg pairwise corr: {avg_corr:+.2f} (low = diversification works)")
|
|
print(f" COMBINED (risk-parity + vol-target 10%): Sharpe {sh:+.2f} ann {100*a:+.1f}% maxDD {100*dd:+.1f}%")
|
|
print(f" vs best single stream Sharpe {best:+.2f} -> diversification lift {sh-best:+.2f}")
|
|
print(f" per-year Sharpe: " + " ".join(f"{y}:{stats(combo[year == y])[2]:+.1f}" for y in sorted(set(year)) if (year == y).sum() > 100))
|
|
print(f" LEVERAGE scaling (same Sharpe {sh:+.2f}): "
|
|
+ " ".join(f"{lev}x->{100*a*lev:+.0f}%/yr@{int(100*v*lev)}%vol" for lev in (1, 2, 3)))
|
|
return combo
|
|
|
|
|
|
def main():
|
|
roots, days, close, op, inst = load_panel()[:5]
|
|
lc, R, ov, intr = build_returns(close, op, inst)
|
|
T, N = close.shape
|
|
year = (1970 + days / 365.25).astype(int)
|
|
|
|
def C(r):
|
|
return roots.index(r)
|
|
|
|
# trend: diversified long/short TS-momentum across all futures, vol-targeted
|
|
vol63 = np.full_like(lc, np.nan)
|
|
for t in range(63, T):
|
|
vol63[t] = np.nanstd(R[t - 63:t], axis=0)
|
|
iv = 1.0 / np.where(vol63 > 0, vol63, np.nan)
|
|
tsig = np.full_like(lc, np.nan); tsig[252:] = np.sign(lc[252:] - lc[:-252])
|
|
avail = np.isfinite(close) & np.isfinite(vol63) & (vol63 > 0) & np.isfinite(tsig)
|
|
w = np.where(avail, tsig * iv, 0.0); g = np.abs(w).sum(1, keepdims=True); g[g == 0] = 1; w = w / g
|
|
trend = np.zeros(T); trend[1:] = np.sum(w[:-1] * R[1:], axis=1)
|
|
|
|
fut = {"equity": R[:, C("ES")], "bond": R[:, C("ZN")], "gold": R[:, C("GC")],
|
|
"commod": R[:, C("CL")], "trend": trend}
|
|
run(fut, days, year, "TRADITIONAL 5-stream (2010-2026)")
|
|
|
|
# +crypto: align BTC daily returns to futures days
|
|
syms, cdays, cc, _, _ = pit_sweep.load()
|
|
j = syms.index("BTCUSDT"); lcb = np.log(cc[:, j])
|
|
btc = {int(cdays[t]): (lcb[t] - lcb[t - 1]) for t in range(1, len(cdays)) if np.isfinite(lcb[t]) and np.isfinite(lcb[t - 1])}
|
|
mask = np.array([int(d) in btc for d in days])
|
|
idx = np.where(mask)[0]
|
|
if len(idx) > 300:
|
|
sub = {k: v[idx] for k, v in fut.items()}
|
|
sub["crypto"] = np.array([btc[int(days[i])] for i in idx])
|
|
run(sub, days[idx], (1970 + days[idx] / 365.25).astype(int), "6-stream +CRYPTO (2019-2026)")
|
|
print("\nVERDICT: combined Sharpe > best single (diversification real) + leverage scales modest Sharpe")
|
|
print("to real return = the hedge-fund operating model. Honest: this is alt-risk-premia (~0.5-1.0 live),")
|
|
print("levered; NOT market-neutral (long beta falls in everything-down); leverage adds tail + financing.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|