305 lines
13 KiB
Python
305 lines
13 KiB
Python
|
import sys, time
|
||
|
|
from pathlib import Path
|
||
|
|
import numpy as np
|
||
|
|
import pandas as pd
|
||
|
|
from scipy.stats import skew, kurtosis
|
||
|
|
import json
|
||
|
|
|
||
|
|
sys.path.insert(0, str(Path(__file__).parent))
|
||
|
|
|
||
|
|
from nautilus_dolphin.nautilus.alpha_orchestrator import NDAlphaEngine
|
||
|
|
from nautilus_dolphin.nautilus.adaptive_circuit_breaker import AdaptiveCircuitBreaker
|
||
|
|
from nautilus_dolphin.nautilus.ob_features import OBFeatureEngine
|
||
|
|
from nautilus_dolphin.nautilus.ob_provider import MockOBProvider
|
||
|
|
|
||
|
|
VBT_DIR = Path(r"C:\Users\Lenovo\Documents\- DOLPHIN NG HD HCM TSF Predict\vbt_cache")
|
||
|
|
META_COLS = {'timestamp', 'scan_number', 'v50_lambda_max_velocity', 'v150_lambda_max_velocity',
|
||
|
|
'v300_lambda_max_velocity', 'v750_lambda_max_velocity', 'vel_div',
|
||
|
|
'instability_50', 'instability_150'}
|
||
|
|
|
||
|
|
parquet_files = sorted(VBT_DIR.glob("*.parquet"))
|
||
|
|
parquet_files = [p for p in parquet_files if 'catalog' not in str(p)]
|
||
|
|
|
||
|
|
print("Loading data...")
|
||
|
|
all_vols = []
|
||
|
|
for pf in parquet_files[:2]:
|
||
|
|
df = pd.read_parquet(pf)
|
||
|
|
if 'BTCUSDT' not in df.columns: continue
|
||
|
|
pr = df['BTCUSDT'].values
|
||
|
|
for i in range(60, len(pr)):
|
||
|
|
seg = pr[max(0,i-50):i]
|
||
|
|
if len(seg)<10: continue
|
||
|
|
v = float(np.std(np.diff(seg)/seg[:-1]))
|
||
|
|
if v > 0: all_vols.append(v)
|
||
|
|
vol_p60 = float(np.percentile(all_vols, 60))
|
||
|
|
|
||
|
|
pq_data = {}
|
||
|
|
total_bars = 0
|
||
|
|
for pf in parquet_files:
|
||
|
|
df = pd.read_parquet(pf)
|
||
|
|
total_bars += len(df)
|
||
|
|
ac = [c for c in df.columns if c not in META_COLS]
|
||
|
|
bp = df['BTCUSDT'].values if 'BTCUSDT' in df.columns else None
|
||
|
|
dv = np.full(len(df), np.nan)
|
||
|
|
if bp is not None:
|
||
|
|
for i in range(50, len(bp)):
|
||
|
|
seg = bp[max(0,i-50):i]
|
||
|
|
if len(seg)<10: continue
|
||
|
|
dv[i] = float(np.std(np.diff(seg)/seg[:-1]))
|
||
|
|
pq_data[pf.stem] = (df, ac, dv)
|
||
|
|
|
||
|
|
# Initialize systems
|
||
|
|
acb = AdaptiveCircuitBreaker()
|
||
|
|
acb.preload_w750([pf.stem for pf in parquet_files])
|
||
|
|
|
||
|
|
mock = MockOBProvider(imbalance_bias=-0.09, depth_scale=1.0,
|
||
|
|
assets=["BTCUSDT", "ETHUSDT", "BNBUSDT", "SOLUSDT"],
|
||
|
|
imbalance_biases={"BNBUSDT": 0.20, "SOLUSDT": 0.20})
|
||
|
|
ob_engine_inst = OBFeatureEngine(mock)
|
||
|
|
ob_engine_inst.preload_date("mock", mock.get_assets())
|
||
|
|
|
||
|
|
from mc.mc_ml import DolphinForewarner
|
||
|
|
from mc.mc_sampler import MCTrialConfig
|
||
|
|
forewarner = DolphinForewarner(models_dir=str(Path(__file__).parent / "mc_results" / "models"))
|
||
|
|
config = MCTrialConfig(
|
||
|
|
trial_id="LIVE",
|
||
|
|
vel_div_threshold=-0.02, vel_div_extreme=-0.05,
|
||
|
|
min_leverage=0.5, max_leverage=5.0, leverage_convexity=3.0,
|
||
|
|
fraction=0.20, fixed_tp_pct=0.0099, stop_pct=1.0, max_hold_bars=120,
|
||
|
|
use_direction_confirm=True, dc_lookback_bars=7, dc_min_magnitude_bps=0.75,
|
||
|
|
dc_skip_contradicts=True, dc_leverage_boost=1.0, dc_leverage_reduce=0.5,
|
||
|
|
vd_trend_lookback=20, use_sp_fees=True, use_sp_slippage=True,
|
||
|
|
sp_maker_entry_rate=0.62, sp_maker_exit_rate=0.5,
|
||
|
|
use_asset_selection=True, min_irp_alignment=0.45,
|
||
|
|
use_ob_edge=True, ob_edge_bps=5.0, ob_confirm_rate=0.40,
|
||
|
|
ob_imbalance_bias=0.0, ob_depth_scale=1.0,
|
||
|
|
lookback=100, use_alpha_layers=True, use_dynamic_leverage=True,
|
||
|
|
acb_beta_high=1.5, acb_beta_low=0.2, acb_w750_threshold_pct=60.0
|
||
|
|
)
|
||
|
|
report = forewarner.assess(config)
|
||
|
|
is_green = (report.envelope_score > 0.5 and report.champion_probability > 0.6)
|
||
|
|
|
||
|
|
def run_trajectory(name, lev_multiplier, use_ob_engine, dynamic_ceiling=False):
|
||
|
|
ENGINE_KWARGS = dict(
|
||
|
|
initial_capital=25000.0, vel_div_threshold=-0.02, vel_div_extreme=-0.05,
|
||
|
|
min_leverage=0.5, max_leverage=5.0 * lev_multiplier, leverage_convexity=3.0,
|
||
|
|
fraction=0.20, fixed_tp_pct=0.0099, stop_pct=1.0, max_hold_bars=120,
|
||
|
|
use_direction_confirm=True, dc_lookback_bars=7, dc_min_magnitude_bps=0.75,
|
||
|
|
dc_skip_contradicts=True, dc_leverage_boost=1.0, dc_leverage_reduce=0.5,
|
||
|
|
use_asset_selection=True, min_irp_alignment=0.45,
|
||
|
|
use_sp_fees=True, use_sp_slippage=True,
|
||
|
|
use_ob_edge=use_ob_engine, ob_edge_bps=5.0, ob_confirm_rate=0.40,
|
||
|
|
lookback=100, use_alpha_layers=True, use_dynamic_leverage=True, seed=42,
|
||
|
|
)
|
||
|
|
import gc; gc.collect()
|
||
|
|
engine = NDAlphaEngine(**ENGINE_KWARGS)
|
||
|
|
|
||
|
|
if dynamic_ceiling:
|
||
|
|
engine.set_mc_forewarner_status(is_green)
|
||
|
|
|
||
|
|
ob_ref = ob_engine_inst if use_ob_engine else None
|
||
|
|
if ob_ref:
|
||
|
|
engine.set_ob_engine(ob_ref)
|
||
|
|
|
||
|
|
bar_idx = 0; peak_cap = engine.capital; max_dd = 0.0
|
||
|
|
daily_returns = []
|
||
|
|
daily_capitals = [engine.capital]
|
||
|
|
exposure_bars = 0
|
||
|
|
|
||
|
|
for pf in parquet_files:
|
||
|
|
ds = pf.stem
|
||
|
|
cs = engine.capital
|
||
|
|
|
||
|
|
acb_info = acb.get_dynamic_boost_for_date(ds, ob_engine=ob_ref)
|
||
|
|
base_boost = acb_info['boost']
|
||
|
|
beta = acb_info['beta']
|
||
|
|
|
||
|
|
df, acols, dvol = pq_data[ds]
|
||
|
|
ph = {}
|
||
|
|
for ri in range(len(df)):
|
||
|
|
row = df.iloc[ri]; vd = row.get("vel_div")
|
||
|
|
if vd is None or not np.isfinite(vd): bar_idx+=1; continue
|
||
|
|
prices = {}
|
||
|
|
for ac in acols:
|
||
|
|
p = row[ac]
|
||
|
|
if p and p > 0 and np.isfinite(p):
|
||
|
|
prices[ac] = float(p)
|
||
|
|
if ac not in ph: ph[ac] = []
|
||
|
|
ph[ac].append(float(p))
|
||
|
|
if len(ph[ac]) > 500: ph[ac] = ph[ac][-200:]
|
||
|
|
if not prices: bar_idx+=1; continue
|
||
|
|
|
||
|
|
vrok = False if ri < 100 else (np.isfinite(dvol[ri]) and dvol[ri] > vol_p60)
|
||
|
|
if beta > 0:
|
||
|
|
ss = 0.0
|
||
|
|
if vd < -0.02:
|
||
|
|
raw = (-0.02 - float(vd)) / (-0.02 - -0.05)
|
||
|
|
ss = min(1.0, max(0.0, raw)) ** 3.0
|
||
|
|
engine.regime_size_mult = base_boost * (1.0 + beta * ss)
|
||
|
|
else:
|
||
|
|
engine.regime_size_mult = base_boost
|
||
|
|
|
||
|
|
engine.process_bar(bar_idx=bar_idx, vel_div=float(vd), prices=prices, vol_regime_ok=vrok, price_histories=ph)
|
||
|
|
bar_idx += 1
|
||
|
|
if engine.position is not None:
|
||
|
|
exposure_bars += 1
|
||
|
|
|
||
|
|
peak_cap = max(peak_cap, engine.capital)
|
||
|
|
dd = (peak_cap - engine.capital) / peak_cap
|
||
|
|
max_dd = max(max_dd, dd)
|
||
|
|
|
||
|
|
daily_returns.append((engine.capital - cs) / cs if cs > 0 else 0)
|
||
|
|
daily_capitals.append(engine.capital)
|
||
|
|
|
||
|
|
trades = engine.trade_history
|
||
|
|
R = np.array(daily_returns)
|
||
|
|
|
||
|
|
return {
|
||
|
|
'name': name,
|
||
|
|
'daily_returns': R,
|
||
|
|
'daily_capitals': daily_capitals,
|
||
|
|
'trades': len(trades),
|
||
|
|
'exposure_bars': exposure_bars,
|
||
|
|
'max_dd': max_dd
|
||
|
|
}
|
||
|
|
|
||
|
|
def analyze_structural(res):
|
||
|
|
R = res['daily_returns']
|
||
|
|
mu = np.mean(R)
|
||
|
|
var = np.var(R, ddof=1)
|
||
|
|
sk = skew(R)
|
||
|
|
kur = kurtosis(R)
|
||
|
|
p95_neg = np.percentile(R[R < 0], 5) if len(R[R<0])>0 else 0
|
||
|
|
exposure_pct = res['exposure_bars'] / total_bars * 100 if total_bars > 0 else 0
|
||
|
|
|
||
|
|
# Loss clustering
|
||
|
|
max_loss_streak = 0
|
||
|
|
curr_streak = 0
|
||
|
|
for r in R:
|
||
|
|
if r < 0:
|
||
|
|
curr_streak += 1
|
||
|
|
max_loss_streak = max(max_loss_streak, curr_streak)
|
||
|
|
else:
|
||
|
|
curr_streak = 0
|
||
|
|
|
||
|
|
# Autocorrelation lag 1
|
||
|
|
if len(R) > 1:
|
||
|
|
autocorr = np.corrcoef(R[:-1], R[1:])[0, 1]
|
||
|
|
else:
|
||
|
|
autocorr = 0
|
||
|
|
|
||
|
|
# Geometric growth rate
|
||
|
|
ggr_daily = np.mean(np.log1p(R))
|
||
|
|
|
||
|
|
return {
|
||
|
|
'mu': mu, 'var': var, 'skew': sk, 'kurt': kur,
|
||
|
|
'p95_neg': p95_neg, 'max_loss_streak': max_loss_streak,
|
||
|
|
'trades': res['trades'], 'exposure_pct': exposure_pct,
|
||
|
|
'autocorr': autocorr, 'ggr_daily': ggr_daily
|
||
|
|
}
|
||
|
|
|
||
|
|
print("\n--- STEP 1 & 2: Compare Before OB vs After OB (5.0x) ---")
|
||
|
|
res_no_ob = run_trajectory("No OB 5x", 1.0, False)
|
||
|
|
res_ob = run_trajectory("OB 5x", 1.0, True)
|
||
|
|
|
||
|
|
st_no = analyze_structural(res_no_ob)
|
||
|
|
st_ob = analyze_structural(res_ob)
|
||
|
|
|
||
|
|
print(f"{'Metric':<25} | {'Before OB':<15} | {'After OB':<15} | {'Delta'}")
|
||
|
|
print("-" * 75)
|
||
|
|
print(f"{'Arithmetic Mean (u)':<25} | {st_no['mu']:<15.6f} | {st_ob['mu']:<15.6f} | {st_ob['mu'] - st_no['mu']:+.6f}")
|
||
|
|
print(f"{'Daily Variance (s2)':<25} | {st_no['var']:<15.6f} | {st_ob['var']:<15.6f} | {st_ob['var'] - st_no['var']:+.6f}")
|
||
|
|
print(f"{'Skew':<25} | {st_no['skew']:<15.3f} | {st_ob['skew']:<15.3f} | {st_ob['skew'] - st_no['skew']:+.3f}")
|
||
|
|
print(f"{'Kurtosis':<25} | {st_no['kurt']:<15.3f} | {st_ob['kurt']:<15.3f} | {st_ob['kurt'] - st_no['kurt']:+.3f}")
|
||
|
|
print(f"{'95th %ile Neg Return':<25} | {st_no['p95_neg']:<15.4f} | {st_ob['p95_neg']:<15.4f} | {st_ob['p95_neg'] - st_no['p95_neg']:+.4f}")
|
||
|
|
print(f"{'Max Loss Streak (Days)':<25} | {st_no['max_loss_streak']:<15} | {st_ob['max_loss_streak']:<15} | {st_ob['max_loss_streak'] - st_no['max_loss_streak']:+}")
|
||
|
|
print(f"{'Trade Count':<25} | {st_no['trades']:<15} | {st_ob['trades']:<15} | {st_ob['trades'] - st_no['trades']:+}")
|
||
|
|
print(f"{'Exposure Time %':<25} | {st_no['exposure_pct']:<14.2f}% | {st_ob['exposure_pct']:<14.2f}% | {st_ob['exposure_pct'] - st_no['exposure_pct']:+.2f}%")
|
||
|
|
print(f"{'Autocorrelation (Lag 1)':<25} | {st_no['autocorr']:<15.3f} | {st_ob['autocorr']:<15.3f} | {st_ob['autocorr'] - st_no['autocorr']:+.3f}")
|
||
|
|
print(f"{'Geometric Growth Rate':<25} | {st_no['ggr_daily']:<15.6f} | {st_ob['ggr_daily']:<15.6f} | {st_ob['ggr_daily'] - st_no['ggr_daily']:+.6f}")
|
||
|
|
|
||
|
|
print("\n--- STEP 3: Geometric Attribution ---")
|
||
|
|
delta_ggr = st_ob['ggr_daily'] - st_no['ggr_daily']
|
||
|
|
delta_mu = st_ob['mu'] - st_no['mu']
|
||
|
|
delta_var = -(st_ob['var'] - st_no['var']) / 2.0
|
||
|
|
# The rest is tail (skew/kurt terms and higher moments)
|
||
|
|
delta_tail = delta_ggr - (delta_mu + delta_var)
|
||
|
|
print(f"Total Daily GGR Improvement: {delta_ggr:+.6f}")
|
||
|
|
print(f" -> Contrib from Mean (u): {delta_mu:+.6f} ({delta_mu/delta_ggr*100:.1f}%)")
|
||
|
|
print(f" -> Contrib from Variance (s2): {delta_var:+.6f} ({delta_var/delta_ggr*100:.1f}%)")
|
||
|
|
print(f" -> Contrib from Tail Shape: {delta_tail:+.6f} ({delta_tail/delta_ggr*100:.1f}%)")
|
||
|
|
|
||
|
|
|
||
|
|
print("\n--- STEP 4: Fit Variance vs Leverage Curve ---")
|
||
|
|
levs = [5.0, 5.5, 6.0, 6.5, 7.0]
|
||
|
|
curve_results = []
|
||
|
|
for l in levs:
|
||
|
|
res = run_trajectory(f"OB {l}x", l/5.0, True)
|
||
|
|
st = analyze_structural(res)
|
||
|
|
curve_results.append((l, st['mu'], st['var'], st['ggr_daily']))
|
||
|
|
|
||
|
|
print(f"{'Leverage':<10} | {'Mu':<10} | {'Var (s2)':<10} | {'Marginal u':<12} | {'Marginal s2/2':<15} | {'GGR (Daily)'}")
|
||
|
|
print("-" * 80)
|
||
|
|
prev_mu, prev_var = None, None
|
||
|
|
for l, mu, var, ggr in curve_results:
|
||
|
|
marg_mu = mu - prev_mu if prev_mu else 0
|
||
|
|
marg_var_2 = (var - prev_var)/2 if prev_var else 0
|
||
|
|
print(f"{l:<10.1f} | {mu:<10.6f} | {var:<10.6f} | {marg_mu:<12.6f} | {marg_var_2:<15.6f} | {ggr:.6f}")
|
||
|
|
prev_mu, prev_var = mu, var
|
||
|
|
|
||
|
|
print("\n=> Geometric Growth caps out roughly where Marginal u < Marginal s2/2")
|
||
|
|
|
||
|
|
|
||
|
|
print("\n--- STEP 5: Monte Carlo Simulation (Static 5x vs Static 6x vs Dynamic 5->6x) ---")
|
||
|
|
def run_mc_sim(baseline_returns, periods=365, n_simulations=1000):
|
||
|
|
np.random.seed(42)
|
||
|
|
daily_returns = baseline_returns
|
||
|
|
|
||
|
|
simulated_returns = np.random.choice(daily_returns, size=(n_simulations, periods), replace=True)
|
||
|
|
equity_curves = np.cumprod(1.0 + simulated_returns, axis=1)
|
||
|
|
cagrs = (equity_curves[:, -1] - 1.0) * 100
|
||
|
|
|
||
|
|
median_cagr = np.median(cagrs)
|
||
|
|
p05_cagr = np.percentile(cagrs, 5)
|
||
|
|
|
||
|
|
max_dds = np.zeros(n_simulations)
|
||
|
|
recovery_times = np.zeros(n_simulations)
|
||
|
|
|
||
|
|
for i in range(n_simulations):
|
||
|
|
curve = equity_curves[i]
|
||
|
|
peaks = np.maximum.accumulate(curve)
|
||
|
|
drawdowns = (peaks - curve) / peaks
|
||
|
|
max_dd_idx = np.argmax(drawdowns)
|
||
|
|
max_dds[i] = drawdowns[max_dd_idx]
|
||
|
|
|
||
|
|
if drawdowns[max_dd_idx] > 0:
|
||
|
|
peak_val = peaks[max_dd_idx]
|
||
|
|
recovery_idx = -1
|
||
|
|
for j in range(max_dd_idx, periods):
|
||
|
|
if curve[j] >= peak_val:
|
||
|
|
recovery_idx = j
|
||
|
|
break
|
||
|
|
|
||
|
|
if recovery_idx != -1:
|
||
|
|
recovery_times[i] = recovery_idx - max_dd_idx
|
||
|
|
else:
|
||
|
|
recovery_times[i] = periods - max_dd_idx
|
||
|
|
|
||
|
|
prob_40dd = np.mean(max_dds >= 0.40) * 100
|
||
|
|
median_rec = np.median(recovery_times[recovery_times > 0]) if np.any(recovery_times > 0) else -1
|
||
|
|
return median_cagr, p05_cagr, prob_40dd, median_rec
|
||
|
|
|
||
|
|
res_5x = run_trajectory("Static 5x", 1.0, True, False)
|
||
|
|
res_6x = run_trajectory("Static 6x", 1.2, True, False)
|
||
|
|
res_dyn = run_trajectory("Dynamic 5->6x", 1.0, True, True)
|
||
|
|
|
||
|
|
mc_5x = run_mc_sim(res_5x['daily_returns'])
|
||
|
|
mc_6x = run_mc_sim(res_6x['daily_returns'])
|
||
|
|
mc_dyn = run_mc_sim(res_dyn['daily_returns'])
|
||
|
|
|
||
|
|
print(f"{'Strategy':<15} | {'Med CAGR':<15} | {'5% CAGR':<15} | {'P(>40% DD)':<15} | {'Median Recovery'}")
|
||
|
|
print("-" * 80)
|
||
|
|
print(f"{'Static 5x':<15} | {mc_5x[0]:<14.2f}% | {mc_5x[1]:<14.2f}% | {mc_5x[2]:<14.2f}% | {mc_5x[3]:.1f} days")
|
||
|
|
print(f"{'Static 6x':<15} | {mc_6x[0]:<14.2f}% | {mc_6x[1]:<14.2f}% | {mc_6x[2]:<14.2f}% | {mc_6x[3]:.1f} days")
|
||
|
|
print(f"{'Dyn 5->6x':<15} | {mc_dyn[0]:<14.2f}% | {mc_dyn[1]:<14.2f}% | {mc_dyn[2]:<14.2f}% | {mc_dyn[3]:.1f} days")
|