DOLPHIN/nautilus_dolphin/test_pf_acb_bidir.py

"""Bi-Directional ACB-Regime-Guided backtest.

ACB external factors determine daily regime:
  0 signals → LONG (calm), size_mult=0.5
  1 signal  → NEUTRAL (minimal SHORT), size_mult=0.3
  2 signals → SHORT (stress), size_mult=1.0
  3+ signals→ SHORT (crash), size_mult=1.25

Intraday DD guard: LONG day >2% DD → halt; SHORT day >4% DD → halt.
"""
import sys, time
from pathlib import Path
from collections import Counter
import numpy as np
import pandas as pd

sys.path.insert(0, str(Path(__file__).parent))

print("Compiling numba kernels...")
t_jit = time.time()
from nautilus_dolphin.nautilus.alpha_asset_selector import compute_irp_nb, compute_ars_nb, rank_assets_irp_nb
from nautilus_dolphin.nautilus.alpha_bet_sizer import compute_sizing_nb
from nautilus_dolphin.nautilus.alpha_signal_generator import check_dc_nb
_p = np.array([1.0, 2.0, 3.0], dtype=np.float64)
compute_irp_nb(_p, -1)
compute_ars_nb(1.0, 0.5, 0.01)
rank_assets_irp_nb(np.ones((10, 2), dtype=np.float64), 8, -1, 5, 500.0, 20, 0.20)
compute_sizing_nb(-0.03, -0.02, -0.05, 3.0, 0.5, 5.0, 0.20, True, True, 0.0,
                  np.zeros(4, dtype=np.int64), np.zeros(4, dtype=np.int64),
                  np.zeros(5, dtype=np.float64), 0, -1, 0.01, 0.04)
check_dc_nb(_p, 3, 1, 0.75)
print(f"  JIT compile: {time.time() - t_jit:.1f}s")

from nautilus_dolphin.nautilus.alpha_orchestrator import NDAlphaEngine
from nautilus_dolphin.nautilus.adaptive_circuit_breaker import AdaptiveCircuitBreaker

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'}

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, 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,
    sp_maker_entry_rate=0.62, sp_maker_exit_rate=0.50,
    use_ob_edge=True, ob_edge_bps=5.0, ob_confirm_rate=0.40,
    lookback=100, use_alpha_layers=True, use_dynamic_leverage=True, seed=42,
)

# ACB signals per date
acb = AdaptiveCircuitBreaker()
parquet_files = sorted(VBT_DIR.glob("*.parquet"))
acb_cuts = {pf.stem: acb.get_cut_for_date(pf.stem) for pf in parquet_files}

# Regime mapping
def get_regime(cut_info):
    """Map ACB signals to regime direction and size multiplier."""
    s = cut_info['signals']
    if s >= 3:
        return -1, 1.25   # SHORT crash: boost
    elif s >= 2:
        return -1, 1.0    # SHORT stress: full size
    elif s >= 1:
        return -1, 0.3    # NEUTRAL: minimal SHORT
    else:
        return +1, 0.5    # LONG calm: conservative

print("\n=== Regime Map ===")
for pf in parquet_files:
    d = pf.stem
    ci = acb_cuts[d]
    direction, mult = get_regime(ci)
    label = "LONG" if direction == 1 else "SHORT"
    if ci['signals'] > 0:
        print(f"  {d}: {label} x{mult:.2f} (signals={ci['signals']:.1f})")
long_days = sum(1 for pf in parquet_files if get_regime(acb_cuts[pf.stem])[0] == 1)
short_days = len(parquet_files) - long_days
print(f"\nLONG days: {long_days}, SHORT days: {short_days}")

# Vol percentiles
all_vols = []
for pf in parquet_files[:2]:
    df = pd.read_parquet(pf)
    if 'BTCUSDT' not in df.columns:
        continue
    prices = df['BTCUSDT'].values
    for i in range(60, len(prices)):
        seg = prices[max(0, i-50):i]
        if len(seg) < 10:
            continue
        rets = np.diff(seg) / seg[:-1]
        v = float(np.std(rets))
        if v > 0:
            all_vols.append(v)
vol_p60 = float(np.percentile(all_vols, 60))


def run_backtest(mode="baseline"):
    """mode: 'baseline' (SHORT-only) or 'bidir' (regime-guided)."""
    engine = NDAlphaEngine(**ENGINE_KWARGS)
    bar_idx = 0
    price_histories = {}
    date_stats = []
    peak_capital = engine.capital
    max_dd = 0.0

    for pf in parquet_files:
        date_str = pf.stem
        cap_start = engine.capital
        trades_start = len(engine.trade_history)

        # Set regime
        if mode == "bidir":
            direction, size_mult = get_regime(acb_cuts[date_str])
            engine.regime_direction = direction
            engine.regime_size_mult = size_mult
        else:
            engine.regime_direction = -1
            engine.regime_size_mult = 1.0

        engine.regime_dd_halt = False
        day_peak = cap_start

        # DD thresholds
        dd_threshold = 0.02 if engine.regime_direction == 1 else 0.04

        df = pd.read_parquet(pf)
        asset_cols = [c for c in df.columns if c not in META_COLS]
        btc_prices = df['BTCUSDT'].values if 'BTCUSDT' in df.columns else None
        date_vol = np.full(len(df), np.nan)
        if btc_prices is not None:
            for i in range(50, len(btc_prices)):
                seg = btc_prices[max(0, i-50):i]
                if len(seg) < 10:
                    continue
                rets = np.diff(seg) / seg[:-1]
                date_vol[i] = float(np.std(rets))

        bars_in_date = 0
        for row_i in range(len(df)):
            row = df.iloc[row_i]
            vel_div = row.get("vel_div")
            if vel_div is None or not np.isfinite(vel_div):
                bar_idx += 1
                bars_in_date += 1
                continue
            prices = {}
            for ac in asset_cols:
                p = row[ac]
                if p and p > 0 and np.isfinite(p):
                    prices[ac] = float(p)
                    if ac not in price_histories:
                        price_histories[ac] = []
                    price_histories[ac].append(float(p))
            if not prices:
                bar_idx += 1
                bars_in_date += 1
                continue
            if bars_in_date < 100:
                vol_regime_ok = False
            else:
                v = date_vol[row_i]
                vol_regime_ok = (np.isfinite(v) and v > vol_p60)

            engine.process_bar(
                bar_idx=bar_idx, vel_div=float(vel_div),
                prices=prices, vol_regime_ok=vol_regime_ok,
                price_histories=price_histories,
            )

            # Intraday DD guard
            if mode == "bidir":
                day_peak = max(day_peak, engine.capital)
                if day_peak > 0:
                    intraday_dd = (day_peak - engine.capital) / day_peak
                    if intraday_dd > dd_threshold:
                        engine.regime_dd_halt = True

            bar_idx += 1
            bars_in_date += 1

        cap_end = engine.capital
        date_pnl = cap_end - cap_start
        new_trades = len(engine.trade_history) - trades_start
        peak_capital = max(peak_capital, cap_end)
        dd = (peak_capital - cap_end) / peak_capital * 100 if peak_capital > 0 else 0
        max_dd = max(max_dd, dd)

        date_stats.append({
            'date': date_str, 'pnl': date_pnl,
            'roi_pct': date_pnl / cap_start * 100 if cap_start > 0 else 0,
            'capital': cap_end, 'trades': new_trades, 'dd_pct': dd,
            'direction': engine.regime_direction if mode == "bidir" else -1,
            'size_mult': engine.regime_size_mult if mode == "bidir" else 1.0,
        })

    return engine, date_stats, max_dd, peak_capital


# Run both
print("\n=== Running BASELINE (SHORT-only) ===")
t0 = time.time()
eng_base, stats_base, dd_base, peak_base = run_backtest("baseline")
print(f"  Done: {time.time()-t0:.0f}s")

print("\n=== Running BI-DIRECTIONAL ===")
t1 = time.time()
eng_bidir, stats_bidir, dd_bidir, peak_bidir = run_backtest("bidir")
print(f"  Done: {time.time()-t1:.0f}s")

# Per-date comparison
print(f"\n{'='*100}")
print(f"{'DATE':<12} {'DIR':>5} {'MULT':>5} {'BASE PnL':>10} {'BIDIR PnL':>10} {'DELTA':>10} {'BASE CAP':>10} {'BIDIR CAP':>10} {'B DD%':>7} {'D DD%':>7}")
print(f"{'='*100}")

for sb, sd in zip(stats_base, stats_bidir):
    d = "LONG" if sd['direction'] == 1 else "SHORT"
    marker = ""
    if sd['pnl'] > sb['pnl'] + 50:
        marker = " ++"
    elif sd['pnl'] < sb['pnl'] - 50:
        marker = " --"
    print(f"{sb['date']:<12} {d:>5} {sd['size_mult']:>5.2f} {sb['pnl']:>+10.2f} {sd['pnl']:>+10.2f} "
          f"{sd['pnl']-sb['pnl']:>+10.2f} {sb['capital']:>10.2f} {sd['capital']:>10.2f} "
          f"{sb['dd_pct']:>6.2f}% {sd['dd_pct']:>6.2f}%{marker}")

# Key metrics
print(f"\n--- LONG DAYS PERFORMANCE ---")
long_base_pnl = sum(sb['pnl'] for sb, sd in zip(stats_base, stats_bidir) if sd['direction'] == 1)
long_bidir_pnl = sum(sd['pnl'] for sb, sd in zip(stats_base, stats_bidir) if sd['direction'] == 1)
print(f"  Base (SHORT on calm days): ${long_base_pnl:+.2f}")
print(f"  Bidir (LONG on calm days): ${long_bidir_pnl:+.2f}")
print(f"  Delta: ${long_bidir_pnl - long_base_pnl:+.2f}")

print(f"\n--- SHORT DAYS PERFORMANCE ---")
short_base_pnl = sum(sb['pnl'] for sb, sd in zip(stats_base, stats_bidir) if sd['direction'] == -1)
short_bidir_pnl = sum(sd['pnl'] for sb, sd in zip(stats_base, stats_bidir) if sd['direction'] == -1)
print(f"  Base (SHORT, no ACB): ${short_base_pnl:+.2f}")
print(f"  Bidir (SHORT, ACB sized): ${short_bidir_pnl:+.2f}")
print(f"  Delta: ${short_bidir_pnl - short_base_pnl:+.2f}")


def summarize(label, engine, max_dd, peak, stats):
    trades = engine.trade_history
    if not trades:
        print(f"\n{label}: 0 trades"); return
    wins = [t for t in trades if t.pnl_absolute > 0]
    losses = [t for t in trades if t.pnl_absolute <= 0]
    gross_win = sum(t.pnl_absolute for t in wins) if wins else 0
    gross_loss = abs(sum(t.pnl_absolute for t in losses)) if losses else 0
    pf_val = gross_win / gross_loss if gross_loss > 0 else float("inf")
    daily_rets = [s['roi_pct'] for s in stats]
    sharpe = np.mean(daily_rets) / np.std(daily_rets) * np.sqrt(365) if np.std(daily_rets) > 0 else 0
    long_trades = [t for t in trades if t.direction == 1]
    short_trades = [t for t in trades if t.direction == -1]

    print(f"\n{'='*50}")
    print(f"  {label}")
    print(f"{'='*50}")
    print(f"Trades: {len(trades)}, WR: {len(wins)/len(trades)*100:.1f}%")
    print(f"  LONG trades: {len(long_trades)}, SHORT trades: {len(short_trades)}")
    if long_trades:
        lw = [t for t in long_trades if t.pnl_absolute > 0]
        print(f"  LONG WR: {len(lw)/len(long_trades)*100:.1f}%")
    if short_trades:
        sw = [t for t in short_trades if t.pnl_absolute > 0]
        print(f"  SHORT WR: {len(sw)/len(short_trades)*100:.1f}%")
    print(f"PF: {pf_val:.3f}")
    print(f"ROI: {(engine.capital - 25000) / 25000 * 100:+.2f}%")
    print(f"Final capital: ${engine.capital:.2f}")
    print(f"Peak capital: ${peak:.2f}")
    print(f"MAX DRAWDOWN: {max_dd:.2f}%")
    print(f"Sharpe (ann.): {sharpe:.2f}")
    print(f"Fees: {engine.total_fees:.2f}")

summarize("BASELINE (SHORT-only)", eng_base, dd_base, peak_base, stats_base)
summarize("BI-DIRECTIONAL (ACB regime)", eng_bidir, dd_bidir, peak_bidir, stats_bidir)

base_roi = (eng_base.capital - 25000) / 25000 * 100
bidir_roi = (eng_bidir.capital - 25000) / 25000 * 100
print(f"\n{'='*50}")
print(f"  DELTA SUMMARY")
print(f"{'='*50}")
print(f"ROI:    {base_roi:+.2f}% -> {bidir_roi:+.2f}% ({bidir_roi-base_roi:+.2f}%)")
print(f"Max DD: {dd_base:.2f}% -> {dd_bidir:.2f}% ({dd_bidir-dd_base:+.2f}%)")
print(f"Total time: {time.time() - t0:.0f}s")