477 lines
22 KiB
Python
477 lines
22 KiB
Python
|
"""Dynamic TP Experiment — per-trade TP variation strategies.
|
|||
|
|
|
|||
|
|
Background
|
|||
|
|
----------
|
|||
|
|
Noise experiment (2026-03-05) showed fixed TP=99bps is sub-optimal:
|
|||
|
|
96% of seeds in ±3bp band beat baseline (+4.3% ΔROI, std=2.17%).
|
|||
|
|
Mechanism: bar-close execution already gives +22bps average overshoot (mean TP exit = 1.21%
|
|||
|
|
not 0.99%). Trades that hit TP at ~53 bars average still have 67 bars of slack — momentum
|
|||
|
|
continues past 99bps more often than it reverses.
|
|||
|
|
|
|||
|
|
Three TP strategies tested (all per-trade, not per-run):
|
|||
|
|
|
|||
|
|
S0 baseline — fixed 99bps for all trades (deterministic reference)
|
|||
|
|
S1a random_3bp — Uniform[96.5, 102.5]bps per trade (anti-detection, ±3bp)
|
|||
|
|
S1b random_7bp — Uniform[92, 106]bps per trade (wider anti-detection radius)
|
|||
|
|
S2a eigen_2bp — TP += 2bp * signal_strength (stronger vel_div → wider TP)
|
|||
|
|
S2b eigen_4bp — TP += 4bp * signal_strength
|
|||
|
|
S2c eigen_6bp — TP += 6bp * signal_strength
|
|||
|
|
S3a regime_boost — TP += 5bp * (acb_boost - 1.0) (high-boost day → wider TP)
|
|||
|
|
S3b regime_vol — TP += 3bp * (regime_mult - 1.0) (high-regime → wider TP)
|
|||
|
|
S4 combined — eigen_3bp + regime_2bp + random_jitter_1bp (meta-bias)
|
|||
|
|
|
|||
|
|
Logging
|
|||
|
|
-------
|
|||
|
|
Per-trade CSV: all engine state + entry features + tp_target_used + tp_strategy
|
|||
|
|
Daily CSV: date, pnl, capital, boost, beta, mc_status
|
|||
|
|
Summary JSON: all hyperparams + stats per strategy
|
|||
|
|
|
|||
|
|
Branch: experiment/dynamic-tp (no modifications to core engine files)
|
|||
|
|
"""
|
|||
|
|
import sys, time, math, json, csv
|
|||
|
|
sys.stdout.reconfigure(encoding='utf-8', errors='replace')
|
|||
|
|
from pathlib import Path
|
|||
|
|
from datetime import datetime
|
|||
|
|
from typing import Optional, Dict, List
|
|||
|
|
import numpy as np
|
|||
|
|
import pandas as pd
|
|||
|
|
|
|||
|
|
HCM = Path(r"C:\Users\Lenovo\Documents\- DOLPHIN NG HD HCM TSF Predict")
|
|||
|
|
sys.path.insert(0, str(HCM / "nautilus_dolphin"))
|
|||
|
|
|
|||
|
|
VBT_DIR = HCM / "vbt_cache"
|
|||
|
|
MC_MODELS_DIR = str(HCM / "nautilus_dolphin" / "mc_results" / "models")
|
|||
|
|
LOG_DIR = HCM / "nautilus_dolphin" / "run_logs"
|
|||
|
|
LOG_DIR.mkdir(exist_ok=True)
|
|||
|
|
|
|||
|
|
# ── champion engine config (exact) ──────────────────────────────────────────
|
|||
|
|
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'}
|
|||
|
|
|
|||
|
|
BASE_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,
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
MC_BASE_CFG = {
|
|||
|
|
'trial_id': 0, 'vel_div_threshold': -0.020, 'vel_div_extreme': -0.050,
|
|||
|
|
'use_direction_confirm': True, 'dc_lookback_bars': 7,
|
|||
|
|
'dc_min_magnitude_bps': 0.75, 'dc_skip_contradicts': True,
|
|||
|
|
'dc_leverage_boost': 1.00, 'dc_leverage_reduce': 0.50,
|
|||
|
|
'vd_trend_lookback': 10, 'min_leverage': 0.50, 'max_leverage': 5.00,
|
|||
|
|
'leverage_convexity': 3.00, 'fraction': 0.20,
|
|||
|
|
'use_alpha_layers': True, 'use_dynamic_leverage': True,
|
|||
|
|
'fixed_tp_pct': 0.0099, 'stop_pct': 1.00, 'max_hold_bars': 120,
|
|||
|
|
'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.00, 'ob_confirm_rate': 0.40,
|
|||
|
|
'ob_imbalance_bias': -0.09, 'ob_depth_scale': 1.00,
|
|||
|
|
'use_asset_selection': True, 'min_irp_alignment': 0.45, 'lookback': 100,
|
|||
|
|
'acb_beta_high': 0.80, 'acb_beta_low': 0.20, 'acb_w750_threshold_pct': 60,
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
# ── JIT warmup ───────────────────────────────────────────────────────────────
|
|||
|
|
print("JIT warmup...", end='', flush=True)
|
|||
|
|
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
|
|||
|
|
from nautilus_dolphin.nautilus.ob_features import (
|
|||
|
|
OBFeatureEngine, compute_imbalance_nb, compute_depth_1pct_nb,
|
|||
|
|
compute_depth_quality_nb, compute_fill_probability_nb, compute_spread_proxy_nb,
|
|||
|
|
compute_depth_asymmetry_nb, compute_imbalance_persistence_nb,
|
|||
|
|
compute_withdrawal_velocity_nb, compute_market_agreement_nb, compute_cascade_signal_nb,
|
|||
|
|
)
|
|||
|
|
from nautilus_dolphin.nautilus.ob_provider import MockOBProvider
|
|||
|
|
_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, np.int64), np.zeros(4, np.int64), np.zeros(5, np.float64), 0, -1, 0.01, 0.04)
|
|||
|
|
check_dc_nb(_p, 3, 1, 0.75)
|
|||
|
|
_b = np.array([100., 200., 300., 400., 500.], dtype=np.float64)
|
|||
|
|
_a = np.array([110., 190., 310., 390., 510.], dtype=np.float64)
|
|||
|
|
compute_imbalance_nb(_b, _a); compute_depth_1pct_nb(_b, _a)
|
|||
|
|
compute_depth_quality_nb(210., 200.); compute_fill_probability_nb(1.0)
|
|||
|
|
compute_spread_proxy_nb(_b, _a); compute_depth_asymmetry_nb(_b, _a)
|
|||
|
|
compute_imbalance_persistence_nb(np.array([0.1, -0.1], dtype=np.float64), 2)
|
|||
|
|
compute_withdrawal_velocity_nb(np.array([100., 110.], dtype=np.float64), 1)
|
|||
|
|
compute_market_agreement_nb(np.array([0.1, -0.05], dtype=np.float64), 2)
|
|||
|
|
compute_cascade_signal_nb(np.array([-0.05, -0.15], dtype=np.float64), 2, -0.10)
|
|||
|
|
print(f" {time.time()-t_jit:.1f}s")
|
|||
|
|
|
|||
|
|
from nautilus_dolphin.nautilus.esf_alpha_orchestrator import NDAlphaEngine
|
|||
|
|
from nautilus_dolphin.nautilus.adaptive_circuit_breaker import AdaptiveCircuitBreaker
|
|||
|
|
from mc.mc_ml import DolphinForewarner
|
|||
|
|
|
|||
|
|
# ── DynamicTPEngine — subclass, no core file modification ───────────────────
|
|||
|
|
class DynamicTPEngine(NDAlphaEngine):
|
|||
|
|
"""NDAlphaEngine subclass that applies per-trade dynamic TP strategies.
|
|||
|
|
|
|||
|
|
Injection point: overrides _try_entry() to set exit_manager.fixed_tp_pct
|
|||
|
|
immediately before position open. Restores base TP afterward.
|
|||
|
|
Records per-trade: tp_target, entry_vel_div, entry_boost, entry_beta,
|
|||
|
|
entry_regime_mult, entry_leverage, entry_v50_vel, entry_v750_vel.
|
|||
|
|
"""
|
|||
|
|
|
|||
|
|
def configure_tp_strategy(self, strategy: str, params: dict, seed: int = 0):
|
|||
|
|
self._tp_strategy = strategy
|
|||
|
|
self._tp_params = params
|
|||
|
|
self._base_tp = self.exit_manager.fixed_tp_pct
|
|||
|
|
self._tp_record: Dict[str, dict] = {} # trade_id → entry metadata
|
|||
|
|
self._rng_tp = np.random.default_rng(seed)
|
|||
|
|
self._vd_threshold = self.vel_div_threshold # -0.02
|
|||
|
|
self._vd_extreme = self.vel_div_extreme # -0.05
|
|||
|
|
|
|||
|
|
def _compute_tp(self, vel_div: float) -> float:
|
|||
|
|
base = self._base_tp
|
|||
|
|
strat = self._tp_strategy
|
|||
|
|
p = self._tp_params
|
|||
|
|
|
|||
|
|
if strat == 'baseline':
|
|||
|
|
return base
|
|||
|
|
|
|||
|
|
elif strat == 'random_uniform':
|
|||
|
|
# Anti-detection: uniform within ±radius
|
|||
|
|
r = p['radius']
|
|||
|
|
return float(self._rng_tp.uniform(base - r, base + r))
|
|||
|
|
|
|||
|
|
elif strat == 'eigen_biased':
|
|||
|
|
# Signal strength in [0,1]: 0 = at threshold, 1 = at extreme
|
|||
|
|
strength = min(1.0, max(0.0,
|
|||
|
|
(self._vd_threshold - vel_div) /
|
|||
|
|
(self._vd_threshold - self._vd_extreme)
|
|||
|
|
))
|
|||
|
|
return base + p['k'] * strength
|
|||
|
|
|
|||
|
|
elif strat == 'regime_biased':
|
|||
|
|
# ACB boost contribution
|
|||
|
|
boost_delta = max(0.0, getattr(self, '_day_base_boost', 1.0) - 1.0)
|
|||
|
|
regime_delta = max(0.0, getattr(self, 'regime_size_mult', 1.0) - 1.0)
|
|||
|
|
return base + p['alpha'] * boost_delta + p['gamma'] * regime_delta
|
|||
|
|
|
|||
|
|
elif strat == 'combined':
|
|||
|
|
# Eigenvalue component
|
|||
|
|
strength = min(1.0, max(0.0,
|
|||
|
|
(self._vd_threshold - vel_div) /
|
|||
|
|
(self._vd_threshold - self._vd_extreme)
|
|||
|
|
))
|
|||
|
|
eigen_part = p['k_eigen'] * strength
|
|||
|
|
# Regime component
|
|||
|
|
boost_delta = max(0.0, getattr(self, '_day_base_boost', 1.0) - 1.0)
|
|||
|
|
regime_part = p['k_regime'] * boost_delta
|
|||
|
|
# Random jitter (anti-detection noise on top of signal-derived TP)
|
|||
|
|
jitter = float(self._rng_tp.normal(0, p['jitter_sigma']))
|
|||
|
|
return base + eigen_part + regime_part + jitter
|
|||
|
|
|
|||
|
|
return base
|
|||
|
|
|
|||
|
|
def _try_entry(self, bar_idx: int, vel_div: float, prices: Dict[str, float],
|
|||
|
|
price_histories, v50_vel: float = 0.0, v750_vel: float = 0.0):
|
|||
|
|
# Compute and inject per-trade TP before position opens
|
|||
|
|
dynamic_tp = float(np.clip(self._compute_tp(vel_div),
|
|||
|
|
0.003, 0.030)) # hard bounds: 30bps–300bps
|
|||
|
|
self.exit_manager.fixed_tp_pct = dynamic_tp
|
|||
|
|
|
|||
|
|
# Record pre-entry state for logging
|
|||
|
|
pre_n_trades = len(self.trade_history)
|
|||
|
|
pre_pos = self.position
|
|||
|
|
|
|||
|
|
result = super()._try_entry(bar_idx, vel_div, prices, price_histories,
|
|||
|
|
v50_vel, v750_vel)
|
|||
|
|
|
|||
|
|
# If a new position was opened, tag it
|
|||
|
|
if self.position is not None and self.position is not pre_pos:
|
|||
|
|
tid = self.position.trade_id
|
|||
|
|
if tid not in self._tp_record:
|
|||
|
|
self._tp_record[tid] = {
|
|||
|
|
'tp_target_bps' : round(dynamic_tp * 10000, 3),
|
|||
|
|
'entry_vel_div' : round(vel_div, 6),
|
|||
|
|
'entry_v50_vel' : round(v50_vel, 8),
|
|||
|
|
'entry_v750_vel' : round(v750_vel, 8),
|
|||
|
|
'entry_boost' : round(getattr(self, '_day_base_boost', 1.0), 4),
|
|||
|
|
'entry_beta' : round(getattr(self, '_day_beta', 0.0), 2),
|
|||
|
|
'entry_regime' : round(getattr(self, 'regime_size_mult', 1.0), 4),
|
|||
|
|
'signal_strength': round(min(1.0, max(0.0,
|
|||
|
|
(self._vd_threshold - vel_div) /
|
|||
|
|
(self._vd_threshold - self._vd_extreme))), 4),
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return result
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ── shared infrastructure (loaded once) ─────────────────────────────────────
|
|||
|
|
print("Loading MC-Forewarner...", end='', flush=True)
|
|||
|
|
forewarner = DolphinForewarner(models_dir=MC_MODELS_DIR)
|
|||
|
|
print(" OK")
|
|||
|
|
|
|||
|
|
parquet_files = sorted([p for p in VBT_DIR.glob("*.parquet") if 'catalog' not in str(p)])
|
|||
|
|
date_strings = [pf.stem for pf in parquet_files]
|
|||
|
|
|
|||
|
|
print("Initializing ACB...", end='', flush=True)
|
|||
|
|
acb = AdaptiveCircuitBreaker()
|
|||
|
|
acb.preload_w750(date_strings)
|
|||
|
|
print(f" OK (p60={acb._w750_threshold:.6f})")
|
|||
|
|
|
|||
|
|
OB_ASSETS = ["BTCUSDT", "ETHUSDT", "BNBUSDT", "SOLUSDT"]
|
|||
|
|
_mock_ob = MockOBProvider(
|
|||
|
|
imbalance_bias=-0.09, depth_scale=1.0, assets=OB_ASSETS,
|
|||
|
|
imbalance_biases={"BTCUSDT": -0.086, "ETHUSDT": -0.092,
|
|||
|
|
"BNBUSDT": +0.05, "SOLUSDT": +0.05},
|
|||
|
|
)
|
|||
|
|
ob_eng = OBFeatureEngine(_mock_ob)
|
|||
|
|
ob_eng.preload_date("mock", OB_ASSETS)
|
|||
|
|
|
|||
|
|
print("Pre-loading parquet data...", end='', flush=True)
|
|||
|
|
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:
|
|||
|
|
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 = {}
|
|||
|
|
for pf in parquet_files:
|
|||
|
|
df = pd.read_parquet(pf)
|
|||
|
|
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:
|
|||
|
|
dv[i] = float(np.std(np.diff(seg) / seg[:-1]))
|
|||
|
|
pq_data[pf.stem] = (df, ac, dv)
|
|||
|
|
print(f" {len(pq_data)} days")
|
|||
|
|
|
|||
|
|
# ── run one engine configuration ─────────────────────────────────────────────
|
|||
|
|
def run_one(strategy: str, params: dict, seed: int, label: str) -> dict:
|
|||
|
|
eng = DynamicTPEngine(**BASE_ENGINE_KWARGS)
|
|||
|
|
eng.set_ob_engine(ob_eng)
|
|||
|
|
eng.set_acb(acb)
|
|||
|
|
eng.set_mc_forewarner(forewarner, MC_BASE_CFG)
|
|||
|
|
eng.set_esoteric_hazard_multiplier(0.0)
|
|||
|
|
eng.configure_tp_strategy(strategy, params, seed=seed)
|
|||
|
|
|
|||
|
|
dstats = []
|
|||
|
|
for pf in parquet_files:
|
|||
|
|
ds = pf.stem
|
|||
|
|
df, acols, dvol = pq_data[ds]
|
|||
|
|
vol_ok = np.where(np.isfinite(dvol), dvol > vol_p60, False)
|
|||
|
|
stats = eng.process_day(ds, df, acols, vol_regime_ok=vol_ok)
|
|||
|
|
dstats.append({**stats, 'cap': eng.capital})
|
|||
|
|
|
|||
|
|
tr = eng.trade_history
|
|||
|
|
wins = [t for t in tr if t.pnl_absolute > 0]
|
|||
|
|
loss = [t for t in tr if t.pnl_absolute <= 0]
|
|||
|
|
gw = sum(t.pnl_absolute for t in wins) if wins else 0.0
|
|||
|
|
gl = abs(sum(t.pnl_absolute for t in loss)) if loss else 0.0
|
|||
|
|
roi = (eng.capital - 25000.0) / 25000.0 * 100
|
|||
|
|
pff = gw / gl if gl > 0 else 999.0
|
|||
|
|
dr = np.array([s['pnl'] / 25000.0 * 100 for s in dstats])
|
|||
|
|
sh = float(np.mean(dr) / np.std(dr) * np.sqrt(365)) if np.std(dr) > 0 else 0.0
|
|||
|
|
pk = 25000.0; mdd = 0.0
|
|||
|
|
for s in dstats:
|
|||
|
|
pk = max(pk, s['cap']); mdd = max(mdd, (pk - s['cap']) / pk * 100)
|
|||
|
|
wr = len(wins) / len(tr) * 100 if tr else 0.0
|
|||
|
|
tp_exits = sum(1 for t in tr if t.exit_reason == 'FIXED_TP')
|
|||
|
|
mh_exits = sum(1 for t in tr if t.exit_reason == 'MAX_HOLD')
|
|||
|
|
|
|||
|
|
# TP stats from record
|
|||
|
|
tp_targets = [eng._tp_record.get(t.trade_id, {}).get('tp_target_bps', 99.0) for t in tr]
|
|||
|
|
tp_arr = np.array(tp_targets)
|
|||
|
|
|
|||
|
|
return dict(
|
|||
|
|
label=label, strategy=strategy, seed=seed,
|
|||
|
|
roi=roi, pf=pff, dd=mdd, sharpe=sh, wr=wr, trades=len(tr), capital=eng.capital,
|
|||
|
|
tp_exits=tp_exits, mh_exits=mh_exits,
|
|||
|
|
tp_mean_bps=float(np.mean(tp_arr)), tp_std_bps=float(np.std(tp_arr)),
|
|||
|
|
tp_min_bps=float(np.min(tp_arr)), tp_max_bps=float(np.max(tp_arr)),
|
|||
|
|
_engine=eng, _dstats=dstats,
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
# ── experiment plan ───────────────────────────────────────────────────────────
|
|||
|
|
N_RANDOM_SEEDS = 15
|
|||
|
|
|
|||
|
|
EXPERIMENTS = []
|
|||
|
|
# S0 baseline
|
|||
|
|
EXPERIMENTS.append(('baseline', 'baseline', {}, [0]))
|
|||
|
|
# S1a random ±3bp
|
|||
|
|
EXPERIMENTS.append(('random_3bp', 'random_uniform', {'radius': 0.0003}, list(range(N_RANDOM_SEEDS))))
|
|||
|
|
# S1b random ±7bp
|
|||
|
|
EXPERIMENTS.append(('random_7bp', 'random_uniform', {'radius': 0.0007}, list(range(N_RANDOM_SEEDS))))
|
|||
|
|
# S2 eigenvalue-biased (deterministic — 1 seed each)
|
|||
|
|
for k_bps, kname in [(0.0002, 'eigen_2bp'), (0.0004, 'eigen_4bp'), (0.0006, 'eigen_6bp')]:
|
|||
|
|
EXPERIMENTS.append((kname, 'eigen_biased', {'k': k_bps}, [0]))
|
|||
|
|
# S3 regime-biased (deterministic)
|
|||
|
|
EXPERIMENTS.append(('regime_boost', 'regime_biased', {'alpha': 0.0005, 'gamma': 0.0000}, [0]))
|
|||
|
|
EXPERIMENTS.append(('regime_vol', 'regime_biased', {'alpha': 0.0003, 'gamma': 0.0002}, [0]))
|
|||
|
|
# S4 combined (random component → 10 seeds)
|
|||
|
|
EXPERIMENTS.append(('combined', 'combined',
|
|||
|
|
{'k_eigen': 0.0003, 'k_regime': 0.0002, 'jitter_sigma': 0.0001},
|
|||
|
|
list(range(N_RANDOM_SEEDS))))
|
|||
|
|
|
|||
|
|
total_runs = sum(len(seeds) for _, _, _, seeds in EXPERIMENTS)
|
|||
|
|
|
|||
|
|
# ── output files ──────────────────────────────────────────────────────────────
|
|||
|
|
run_ts = datetime.now().strftime("%Y%m%d_%H%M%S")
|
|||
|
|
sum_path = LOG_DIR / f"dyntp_summary_{run_ts}.csv"
|
|||
|
|
trade_path= LOG_DIR / f"dyntp_trades_{run_ts}.csv"
|
|||
|
|
daily_path= LOG_DIR / f"dyntp_daily_{run_ts}.csv"
|
|||
|
|
|
|||
|
|
SUM_FIELDS = ['label','strategy','seed','roi','pf','dd','sharpe','wr','trades','capital',
|
|||
|
|
'tp_exits','mh_exits','tp_mean_bps','tp_std_bps','tp_min_bps','tp_max_bps','elapsed_s']
|
|||
|
|
TRADE_FIELDS = ['label','strategy','seed','trade_id','asset','direction',
|
|||
|
|
'entry_price','exit_price','entry_bar','exit_bar','bars_held',
|
|||
|
|
'leverage','notional','pnl_pct_pct','pnl_absolute','exit_reason','bucket_idx',
|
|||
|
|
'tp_target_bps','entry_vel_div','entry_v50_vel','entry_v750_vel',
|
|||
|
|
'entry_boost','entry_beta','entry_regime','signal_strength']
|
|||
|
|
DAILY_FIELDS = ['label','strategy','seed','date','pnl','capital','dd_pct','boost','beta','mc_status','trades']
|
|||
|
|
|
|||
|
|
with open(sum_path, 'w', newline='') as f: csv.writer(f).writerow(SUM_FIELDS)
|
|||
|
|
with open(trade_path, 'w', newline='') as f: csv.writer(f).writerow(TRADE_FIELDS)
|
|||
|
|
with open(daily_path, 'w', newline='') as f: csv.writer(f).writerow(DAILY_FIELDS)
|
|||
|
|
|
|||
|
|
def append_summary(r, elapsed):
|
|||
|
|
with open(sum_path, 'a', newline='') as f:
|
|||
|
|
csv.writer(f).writerow([
|
|||
|
|
r['label'], r['strategy'], r['seed'],
|
|||
|
|
round(r['roi'],4), round(r['pf'],4), round(r['dd'],4),
|
|||
|
|
round(r['sharpe'],4), round(r['wr'],4), r['trades'],
|
|||
|
|
round(r['capital'],4), r['tp_exits'], r['mh_exits'],
|
|||
|
|
round(r['tp_mean_bps'],3), round(r['tp_std_bps'],3),
|
|||
|
|
round(r['tp_min_bps'],3), round(r['tp_max_bps'],3),
|
|||
|
|
round(elapsed,1),
|
|||
|
|
])
|
|||
|
|
|
|||
|
|
def append_trades(r):
|
|||
|
|
eng = r['_engine']
|
|||
|
|
with open(trade_path, 'a', newline='') as f:
|
|||
|
|
cw = csv.writer(f)
|
|||
|
|
for t in eng.trade_history:
|
|||
|
|
meta = eng._tp_record.get(t.trade_id, {})
|
|||
|
|
cw.writerow([
|
|||
|
|
r['label'], r['strategy'], r['seed'],
|
|||
|
|
t.trade_id, t.asset, t.direction,
|
|||
|
|
f"{t.entry_price:.6f}", f"{t.exit_price:.6f}",
|
|||
|
|
t.entry_bar, t.exit_bar, t.bars_held,
|
|||
|
|
f"{t.leverage:.4f}", f"{t.notional:.4f}",
|
|||
|
|
f"{t.pnl_pct*100:.6f}", f"{t.pnl_absolute:.4f}",
|
|||
|
|
t.exit_reason, t.bucket_idx,
|
|||
|
|
meta.get('tp_target_bps', 99.0),
|
|||
|
|
meta.get('entry_vel_div', ''),
|
|||
|
|
meta.get('entry_v50_vel', ''),
|
|||
|
|
meta.get('entry_v750_vel', ''),
|
|||
|
|
meta.get('entry_boost', ''),
|
|||
|
|
meta.get('entry_beta', ''),
|
|||
|
|
meta.get('entry_regime', ''),
|
|||
|
|
meta.get('signal_strength', ''),
|
|||
|
|
])
|
|||
|
|
|
|||
|
|
def append_daily(r):
|
|||
|
|
eng = r['_engine']
|
|||
|
|
with open(daily_path, 'a', newline='') as f:
|
|||
|
|
cw = csv.writer(f)
|
|||
|
|
pk = 25000.0
|
|||
|
|
for s in r['_dstats']:
|
|||
|
|
pk = max(pk, s['cap'])
|
|||
|
|
cw.writerow([
|
|||
|
|
r['label'], r['strategy'], r['seed'],
|
|||
|
|
s['date'], f"{s['pnl']:.4f}", f"{s['cap']:.4f}",
|
|||
|
|
f"{(pk-s['cap'])/pk*100:.4f}",
|
|||
|
|
f"{s['boost']:.4f}", f"{s['beta']:.2f}",
|
|||
|
|
s['mc_status'], s['trades'],
|
|||
|
|
])
|
|||
|
|
|
|||
|
|
# ── main loop ────────────────────────────────────────────────────────────────
|
|||
|
|
print(f"\n{'='*65}")
|
|||
|
|
print(f" DYNAMIC TP EXPERIMENT — {total_runs} total runs")
|
|||
|
|
print(f" Baseline TP: 99bps | Branch: experiment/dynamic-tp")
|
|||
|
|
print(f"{'='*65}\n")
|
|||
|
|
|
|||
|
|
all_results = {}
|
|||
|
|
completed = 0
|
|||
|
|
t_exp = time.time()
|
|||
|
|
|
|||
|
|
for label, strategy, params, seeds in EXPERIMENTS:
|
|||
|
|
n = len(seeds)
|
|||
|
|
print(f" [{label}] strategy={strategy} params={params} n={n}")
|
|||
|
|
all_results[label] = []
|
|||
|
|
|
|||
|
|
for seed in seeds:
|
|||
|
|
t0 = time.time()
|
|||
|
|
r = run_one(strategy, params, seed, label)
|
|||
|
|
elapsed = time.time() - t0
|
|||
|
|
all_results[label].append(r)
|
|||
|
|
completed += 1
|
|||
|
|
eta = (time.time() - t_exp) / completed * (total_runs - completed)
|
|||
|
|
|
|||
|
|
print(f" seed={seed:2d} ROI={r['roi']:+6.2f}% PF={r['pf']:.3f}"
|
|||
|
|
f" DD={r['dd']:.2f}% T={r['trades']}"
|
|||
|
|
f" TP_hits={r['tp_exits']} TP_mean={r['tp_mean_bps']:.1f}bps"
|
|||
|
|
f" [{elapsed:.0f}s | ETA {eta/60:.0f}min]")
|
|||
|
|
|
|||
|
|
append_summary(r, elapsed)
|
|||
|
|
append_trades(r)
|
|||
|
|
append_daily(r)
|
|||
|
|
|
|||
|
|
# ── final analysis ────────────────────────────────────────────────────────────
|
|||
|
|
print(f"\n{'='*65}")
|
|||
|
|
print(f" RESULTS — Dynamic TP Strategies vs Baseline")
|
|||
|
|
print(f"{'='*65}")
|
|||
|
|
|
|||
|
|
b_rois = [r['roi'] for r in all_results.get('baseline', [])]
|
|||
|
|
b_roi = b_rois[0] if b_rois else 44.89
|
|||
|
|
b_tp = all_results.get('baseline', [{}])[0].get('tp_exits', 301)
|
|||
|
|
|
|||
|
|
print(f"\n {'Label':<14} {'E[ROI]':>8} {'ΔROI':>7} {'E[PF]':>6} "
|
|||
|
|
f"{'E[T]':>5} {'TP_exits':>8} {'TP_mean':>8} {'TP_std':>7} {'Beat%':>6}")
|
|||
|
|
print(f" {'-'*85}")
|
|||
|
|
|
|||
|
|
for label, strategy, params, seeds in EXPERIMENTS:
|
|||
|
|
results = all_results[label]
|
|||
|
|
rois = [r['roi'] for r in results]
|
|||
|
|
pfs = [r['pf'] for r in results]
|
|||
|
|
ts = [r['trades'] for r in results]
|
|||
|
|
tpe = [r['tp_exits'] for r in results]
|
|||
|
|
tpmn = [r['tp_mean_bps'] for r in results]
|
|||
|
|
tpsd = [r['tp_std_bps'] for r in results]
|
|||
|
|
|
|||
|
|
mean_roi = float(np.mean(rois))
|
|||
|
|
delta = mean_roi - b_roi
|
|||
|
|
mean_pf = float(np.mean(pfs))
|
|||
|
|
mean_t = float(np.mean(ts))
|
|||
|
|
mean_tpe = float(np.mean(tpe))
|
|||
|
|
mean_tpmn = float(np.mean(tpmn))
|
|||
|
|
mean_tpsd = float(np.mean(tpsd))
|
|||
|
|
beat_pct = float(np.mean(np.array(rois) > b_roi)) * 100 if len(rois) > 1 else (100.0 if mean_roi > b_roi else 0.0)
|
|||
|
|
|
|||
|
|
print(f" {label:<14} {mean_roi:>+7.2f}% {delta:>+6.2f}% {mean_pf:>6.3f} "
|
|||
|
|
f"{mean_t:>5.0f} {mean_tpe:>8.0f} {mean_tpmn:>7.1f}bps "
|
|||
|
|
f"{mean_tpsd:>6.1f}bps {beat_pct:>5.1f}%")
|
|||
|
|
|
|||
|
|
print(f"\n{'='*65}")
|
|||
|
|
print(f" Interpretation:")
|
|||
|
|
print(f" random_*bp: Does randomisation itself help (anti-detection + luck)?")
|
|||
|
|
print(f" eigen_*bp: Does signal-strength-proportional TP add edge?")
|
|||
|
|
print(f" regime_*: Does ACB-boost-proportional TP add edge?")
|
|||
|
|
print(f" combined: Does the meta-bias composite beat individual components?")
|
|||
|
|
print(f"\n Key question: do TP exits increase (wider TP → fewer TP hits)?")
|
|||
|
|
print(f" Or decrease (smarter TP → more precise captures)?")
|
|||
|
|
print(f"\n Files: {sum_path.name} | {trade_path.name} | {daily_path.name}")
|
|||
|
|
print(f" Total time: {(time.time()-t_exp)/60:.1f} min")
|