feat: quant validation framework — DSR, PSR, Haircut, regimes, walk-forward
Three-module quant framework replacing 'sort by Sharpe' with proper statistical validation: quant/significance.py (15 tests): - deflated_sharpe_ratio(): adjusts for N trials (Harvey & Liu 2015) - probabilistic_sharpe_ratio(): P(True SR > benchmark) given T, skew, kurt - sharpe_haircut(): expected OOS Sharpe after selection bias deflation - QuantVerdict: DEPLOY / SIMULATE / DISCARD with 5-point scoring - validate_strategy(): one-shot validation function quant/regimes.py (8 tests): - classify_regime(): trending_up/down, ranging, volatile - RegimeClassifier: stateful rolling-window classifier - conditional_performance(): per-regime trade statistics quant/walkforward.py (5 tests): - WalkForwardRunner: sequential IS/OOS window optimization - WFWindow/WFReport: structured walk-forward results - consistency score, performance decay, concatenated OOS equity - significance_report() integration Walk-forward results (real HL data with date-sliced windows): grid_mm 1h: 2/4 pos, OOS S=-0.45, 74t, haircut=-22.66 → DISCARD momentum 4h: 2/4 pos, OOS S=-1.47, 116t, haircut=-45.35 → DISCARD composite_mm 1h: 2/4 pos, OOS S=+2.97, 6t, haircut=+43.25 → SIMULATE 28 tests total
This commit is contained in:
ramseshk
@@ -0,0 +1,156 @@
|
||||
"""
|
||||
Market regime classification for strategy gating.
|
||||
|
||||
Classifies each bar into one of four regimes based on rolling returns,
|
||||
volatility, and volume profile. Used to compute conditional strategy
|
||||
performance — a strategy that only works in trending regimes must
|
||||
KNOW when it's in a trending regime.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections import deque
|
||||
from typing import Optional
|
||||
|
||||
import numpy as np
|
||||
|
||||
|
||||
def classify_regime(
|
||||
returns_20: float,
|
||||
vol_20: float,
|
||||
vol_ratio: float = 1.0,
|
||||
trend_threshold: float = 0.05,
|
||||
vol_threshold: float = 0.04,
|
||||
) -> str:
|
||||
"""Classify a single bar into a market regime.
|
||||
|
||||
Args:
|
||||
returns_20: rolling 20-bar return (fraction, e.g. 0.15 = +15%)
|
||||
vol_20: rolling 20-bar realized volatility (annualized or period)
|
||||
vol_ratio: current volume / rolling average volume
|
||||
trend_threshold: minimum abs return to classify as trending
|
||||
vol_threshold: volatility above which market is "volatile"
|
||||
|
||||
Returns one of: trending_up, trending_down, ranging, volatile
|
||||
"""
|
||||
if vol_20 > vol_threshold or vol_ratio > 2.0:
|
||||
return "volatile"
|
||||
|
||||
if returns_20 > trend_threshold:
|
||||
return "trending_up"
|
||||
elif returns_20 < -trend_threshold:
|
||||
return "trending_down"
|
||||
else:
|
||||
return "ranging"
|
||||
|
||||
|
||||
class RegimeClassifier:
|
||||
"""Stateful regime classifier using rolling windows.
|
||||
|
||||
Usage:
|
||||
rc = RegimeClassifier(window=20)
|
||||
for bar in bars:
|
||||
rc.feed(mid_px=bar.close, close=bar.close,
|
||||
open_px=bar.open, vol=bar.volume)
|
||||
regime = rc.current_regime
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
window: int = 20,
|
||||
trend_threshold: float = 0.05,
|
||||
vol_threshold: float = 0.04,
|
||||
):
|
||||
self._window = window
|
||||
self._trend_threshold = trend_threshold
|
||||
self._vol_threshold = vol_threshold
|
||||
|
||||
self._prices: deque[float] = deque(maxlen=window + 1)
|
||||
self._volumes: deque[float] = deque(maxlen=window)
|
||||
self._current_regime: str = "unknown"
|
||||
self._regime_counts: dict[str, int] = {"trending_up": 0, "trending_down": 0,
|
||||
"ranging": 0, "volatile": 0, "unknown": 0}
|
||||
|
||||
def feed(self, mid_px: float, close: float, open_px: float, vol: float):
|
||||
"""Feed a new bar observation."""
|
||||
self._prices.append(mid_px)
|
||||
self._volumes.append(vol)
|
||||
|
||||
if len(self._prices) < self._window + 1:
|
||||
return
|
||||
|
||||
# Rolling return
|
||||
returns_20 = (self._prices[-1] - self._prices[0]) / self._prices[0] if self._prices[0] > 0 else 0
|
||||
|
||||
# Rolling volatility
|
||||
price_list = list(self._prices)
|
||||
rets = [(price_list[i] - price_list[i - 1]) / price_list[i - 1]
|
||||
for i in range(1, len(price_list)) if price_list[i - 1] > 0]
|
||||
vol_20 = np.std(rets) if rets else 0.0
|
||||
|
||||
# Volume ratio
|
||||
avg_vol = sum(self._volumes) / max(len(self._volumes), 1)
|
||||
vol_ratio = vol / avg_vol if avg_vol > 0 else 1.0
|
||||
|
||||
self._current_regime = classify_regime(
|
||||
returns_20, vol_20, vol_ratio,
|
||||
self._trend_threshold, self._vol_threshold,
|
||||
)
|
||||
self._regime_counts[self._current_regime] += 1
|
||||
|
||||
@property
|
||||
def current_regime(self) -> str:
|
||||
return self._current_regime
|
||||
|
||||
def regime_counts(self) -> dict[str, int]:
|
||||
return dict(self._regime_counts)
|
||||
|
||||
def dominant_regime(self) -> str:
|
||||
"""Most frequent regime observed so far."""
|
||||
return max(self._regime_counts, key=self._regime_counts.get)
|
||||
|
||||
|
||||
def conditional_performance(
|
||||
trades: list[dict],
|
||||
regime_trade_counts: dict[str, int],
|
||||
) -> dict:
|
||||
"""Compute per-regime strategy performance from trade records.
|
||||
|
||||
Args:
|
||||
trades: list of trade dicts with pnl_net, pnl_gross, time
|
||||
regime_trade_counts: {regime_name: count_of_trades}
|
||||
|
||||
Returns:
|
||||
dict with per-regime stats (avg_pnl, win_rate, total_pnl, count)
|
||||
and best_regime / worst_regime classification.
|
||||
"""
|
||||
# For simplicity, assume all trades belong to the regime
|
||||
# In production, each trade would be timestamp-matched to regime at entry
|
||||
all_pnls = [float(t.get("pnl_net", t.get("pnl", 0))) for t in trades]
|
||||
|
||||
result = {"regimes": {}, "overall": {"count": len(trades), "total_pnl": round(sum(all_pnls), 2)}}
|
||||
|
||||
for regime, count in regime_trade_counts.items():
|
||||
if count == 0:
|
||||
result["regimes"][regime] = {"count": 0, "total_pnl": 0, "avg_pnl": 0, "win_rate": 0}
|
||||
continue
|
||||
|
||||
# Take the next batch of trades for this regime
|
||||
# (simplified — real impl would match by timestamp)
|
||||
regime_pnls = all_pnls[:count]
|
||||
wins = sum(1 for p in regime_pnls if p > 0)
|
||||
|
||||
result["regimes"][regime] = {
|
||||
"count": count,
|
||||
"total_pnl": round(sum(regime_pnls), 2),
|
||||
"avg_pnl": round(sum(regime_pnls) / count, 2) if count else 0,
|
||||
"win_rate": round(wins / count, 3) if count else 0,
|
||||
}
|
||||
|
||||
# Best and worst regime
|
||||
scored = [(r, info["avg_pnl"]) for r, info in result["regimes"].items() if info["count"] > 0]
|
||||
if scored:
|
||||
result["best_regime"] = max(scored, key=lambda x: x[1])[0]
|
||||
result["worst_regime"] = min(scored, key=lambda x: x[1])[0]
|
||||
|
||||
return result
|
||||
@@ -0,0 +1,235 @@
|
||||
"""
|
||||
Statistical significance framework for backtest validation.
|
||||
|
||||
Deflated Sharpe Ratio (Harvey & Liu 2015): adjusts for multiple testing.
|
||||
Probabilistic Sharpe Ratio (Bailey & López de Prado 2012): probability
|
||||
that true Sharpe exceeds a benchmark, given sample size and skew/kurtosis.
|
||||
Haircut: expected OOS Sharpe given IS Sharpe and number of trials.
|
||||
|
||||
QuantVerdict: combines all three into a deploy/simulate/discard decision.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
|
||||
import numpy as np
|
||||
|
||||
# ── Deflated Sharpe Ratio ───────────────────────────────────
|
||||
|
||||
def deflated_sharpe_ratio(
|
||||
sharpe: float,
|
||||
n_trials: int = 1,
|
||||
n_periods: int = 100,
|
||||
) -> float:
|
||||
"""Probability that the true Sharpe ratio exceeds the observed value,
|
||||
adjusted for multiple testing (data snooping).
|
||||
|
||||
DSR = Φ⁻¹[(1 - p)^(1/N)] formulated as a probability.
|
||||
|
||||
Args:
|
||||
sharpe: observed annualized Sharpe ratio
|
||||
n_trials: number of independent strategy variations tested
|
||||
n_periods: number of return observations
|
||||
|
||||
Returns: probability (0-1) that true Sharpe > 0 after deflation.
|
||||
"""
|
||||
if n_trials <= 0 or n_periods <= 0 or math.isnan(sharpe):
|
||||
return 0.0
|
||||
|
||||
# Convert Sharpe to standard normal probability
|
||||
from scipy.stats import norm
|
||||
p_value = 1.0 - norm.cdf(sharpe)
|
||||
|
||||
# Bonferroni-type adjustment for multiple testing
|
||||
adjusted_p = min(1.0, p_value * n_trials)
|
||||
|
||||
# DSR = 1 - adjusted_p (probability true Sharpe > 0)
|
||||
dsr = max(0.0, 1.0 - adjusted_p)
|
||||
return round(dsr, 6)
|
||||
|
||||
|
||||
# ── Probabilistic Sharpe Ratio ──────────────────────────────
|
||||
|
||||
def probabilistic_sharpe_ratio(
|
||||
sharpe: float,
|
||||
n_periods: int,
|
||||
benchmark: float = 0.0,
|
||||
skewness: float = 0.0,
|
||||
kurtosis: float = 3.0,
|
||||
) -> float:
|
||||
"""Probability that the true Sharpe ratio exceeds the benchmark.
|
||||
|
||||
PSR = Φ((ŜR - SR*) * √T / √(1 - γ₃ * ŜR + (γ₄ - 1)/4 * ŜR²))
|
||||
|
||||
Args:
|
||||
sharpe: observed (annualized) Sharpe ratio
|
||||
n_periods: number of return observations
|
||||
benchmark: target Sharpe ratio (default 0)
|
||||
skewness: sample skewness of returns
|
||||
kurtosis: sample kurtosis of returns (normal = 3)
|
||||
|
||||
Returns: probability (0-1) that true SR > benchmark
|
||||
"""
|
||||
if n_periods <= 0 or math.isnan(sharpe):
|
||||
return 0.0
|
||||
|
||||
from scipy.stats import norm
|
||||
|
||||
numerator = (sharpe - benchmark) * math.sqrt(n_periods)
|
||||
denominator = math.sqrt(
|
||||
1.0 - skewness * sharpe + (kurtosis - 1.0) / 4.0 * sharpe * sharpe
|
||||
)
|
||||
|
||||
if denominator <= 0:
|
||||
return 0.5
|
||||
|
||||
z_score = numerator / denominator
|
||||
psr = float(norm.cdf(z_score))
|
||||
return round(psr, 6)
|
||||
|
||||
|
||||
# ── Sharpe Haircut ──────────────────────────────────────────
|
||||
|
||||
def sharpe_haircut(
|
||||
sharpe: float,
|
||||
n_trials: int = 1,
|
||||
n_periods: int = 100,
|
||||
) -> float:
|
||||
"""Expected out-of-sample Sharpe after adjusting for data snooping.
|
||||
|
||||
E[OOS Sharpe] ≈ IS Sharpe - E[max_i Z_i] / √T
|
||||
|
||||
Where E[max_i Z_i] is the expected maximum of N independent
|
||||
standard normals (the selection bias term).
|
||||
|
||||
Args:
|
||||
sharpe: observed in-sample Sharpe ratio
|
||||
n_trials: number of independent trials
|
||||
n_periods: number of observations
|
||||
|
||||
Returns: expected OOS Sharpe ratio (the "haircut" value)
|
||||
"""
|
||||
if n_periods <= 1:
|
||||
n_periods = 1
|
||||
|
||||
n_trials = max(1, n_trials)
|
||||
n_periods = max(2, n_periods)
|
||||
|
||||
if n_trials <= 1:
|
||||
return round(sharpe, 6)
|
||||
|
||||
euler_gamma = 0.5772156649
|
||||
|
||||
# Expected maximum of N independent standard normals
|
||||
log_n = math.log(n_trials)
|
||||
if log_n <= 0:
|
||||
expected_max = 0.0
|
||||
else:
|
||||
expected_max = math.sqrt(2.0 * log_n)
|
||||
log_log_n = math.log(log_n)
|
||||
expected_max -= (log_log_n + math.log(4 * math.pi)) / (2 * math.sqrt(2 * log_n))
|
||||
expected_max += euler_gamma / math.sqrt(2 * log_n)
|
||||
|
||||
expected_max = max(expected_max, 0.0)
|
||||
|
||||
# Deflation: observed - selection bias
|
||||
haircut = sharpe - expected_max / math.sqrt(n_periods)
|
||||
|
||||
return round(haircut, 6)
|
||||
|
||||
|
||||
# ── QuantVerdict ─────────────────────────────────────────────
|
||||
|
||||
class QuantVerdict:
|
||||
"""Combined validation report: DSR + PSR + Haircut + walk-forward.
|
||||
|
||||
Usage:
|
||||
verdict = QuantVerdict(observed_sharpe=2.0, wf_consistency=0.7, ...)
|
||||
report = verdict.evaluate()
|
||||
print(report['verdict'], report['recommendation'])
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
observed_sharpe: float,
|
||||
wf_consistency: float, # fraction of walk-forward windows with positive OOS Sharpe
|
||||
n_trials: int = 1, # total strategies/intervals tested
|
||||
n_periods: int = 100, # return observations
|
||||
positive_regimes: int = 0, # number of regimes with positive Sharpe
|
||||
benchmark_sharpe: float = 0.0,
|
||||
skewness: float = 0.0,
|
||||
kurtosis: float = 3.0,
|
||||
):
|
||||
self.observed_sharpe = observed_sharpe
|
||||
self.wf_consistency = wf_consistency
|
||||
self.n_trials = n_trials
|
||||
self.n_periods = n_periods
|
||||
self.positive_regimes = positive_regimes
|
||||
self.benchmark_sharpe = benchmark_sharpe
|
||||
self.skewness = skewness
|
||||
self.kurtosis = kurtosis
|
||||
|
||||
def evaluate(self) -> dict:
|
||||
dsr = deflated_sharpe_ratio(self.observed_sharpe, self.n_trials, self.n_periods)
|
||||
psr = probabilistic_sharpe_ratio(
|
||||
self.observed_sharpe, self.n_periods,
|
||||
self.benchmark_sharpe, self.skewness, self.kurtosis,
|
||||
)
|
||||
hc = sharpe_haircut(self.observed_sharpe, self.n_trials, self.n_periods)
|
||||
|
||||
# Decision logic
|
||||
score = 0
|
||||
if dsr > 0.80: score += 1
|
||||
if psr > 0.70: score += 1
|
||||
if self.wf_consistency > 0.50: score += 1
|
||||
if self.positive_regimes >= 2: score += 1
|
||||
if hc > 0.5: score += 1
|
||||
|
||||
if score >= 4:
|
||||
verdict = "DEPLOY"
|
||||
rec = "Strategy passes all significance tests. Deploy with 1/10th size + daily PnL stop."
|
||||
elif score >= 2:
|
||||
verdict = "SIMULATE"
|
||||
rec = "Marginal significance. Run through Phase 3 queue simulator before live."
|
||||
else:
|
||||
verdict = "DISCARD"
|
||||
rec = "Fails significance tests. Strategy is indistinguishable from noise."
|
||||
|
||||
return {
|
||||
"verdict": verdict,
|
||||
"deflated_sharpe": dsr,
|
||||
"psr": psr,
|
||||
"haircut_sharpe": hc,
|
||||
"wf_consistency": round(self.wf_consistency, 3),
|
||||
"observed_sharpe": round(self.observed_sharpe, 3),
|
||||
"n_trials": self.n_trials,
|
||||
"n_periods": self.n_periods,
|
||||
"positive_regimes": self.positive_regimes,
|
||||
"skewness": round(self.skewness, 4),
|
||||
"kurtosis": round(self.kurtosis, 4),
|
||||
"score": f"{score}/5",
|
||||
"recommendation": rec,
|
||||
}
|
||||
|
||||
|
||||
def validate_strategy(
|
||||
sharpe: float,
|
||||
n_trades: int,
|
||||
n_trials: int = 1,
|
||||
wf_consistency: float = 0.0,
|
||||
positive_regimes: int = 0,
|
||||
skewness: float = 0.0,
|
||||
kurtosis: float = 3.0,
|
||||
) -> dict:
|
||||
"""Quick one-shot validation of a strategy."""
|
||||
v = QuantVerdict(
|
||||
observed_sharpe=sharpe,
|
||||
n_periods=n_trades,
|
||||
n_trials=n_trials,
|
||||
wf_consistency=wf_consistency,
|
||||
positive_regimes=positive_regimes,
|
||||
skewness=skewness,
|
||||
kurtosis=kurtosis,
|
||||
)
|
||||
return v.evaluate()
|
||||
@@ -0,0 +1,253 @@
|
||||
"""
|
||||
Walk-forward validation framework.
|
||||
|
||||
Splits market data into sequential IS/OOS windows, optimizes strategy
|
||||
parameters on in-sample data, and tests on out-of-sample data. This is
|
||||
the minimum bar for any strategy before live deployment.
|
||||
|
||||
Computes:
|
||||
- OOS Sharpe per window
|
||||
- Walk-forward consistency (% positive OOS windows)
|
||||
- Performance decay (IS → OOS degradation)
|
||||
- Concatenated OOS equity curve
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from typing import Optional
|
||||
|
||||
import numpy as np
|
||||
|
||||
from quant.significance import QuantVerdict
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@dataclass
|
||||
class WFWindow:
|
||||
"""Single walk-forward window result."""
|
||||
window_idx: int
|
||||
is_start: str
|
||||
is_end: str
|
||||
oos_start: str
|
||||
oos_end: str
|
||||
is_sharpe: float
|
||||
oos_sharpe: float
|
||||
is_return_pct: float
|
||||
oos_return_pct: float
|
||||
oos_trades: int
|
||||
best_params: dict = field(default_factory=dict)
|
||||
|
||||
|
||||
@dataclass
|
||||
class WFReport:
|
||||
"""Complete walk-forward analysis report."""
|
||||
strategy: str
|
||||
interval: str
|
||||
n_windows: int
|
||||
windows: list[WFWindow] = field(default_factory=list)
|
||||
oos_equity_curve: list[dict] = field(default_factory=list)
|
||||
|
||||
@property
|
||||
def oos_sharpe(self) -> float:
|
||||
if not self.oos_equity_curve:
|
||||
return 0.0
|
||||
vals = [p["v"] for p in self.oos_equity_curve if p.get("v")]
|
||||
if len(vals) < 2:
|
||||
return 0.0
|
||||
rets = [(vals[i] - vals[i - 1]) / vals[i - 1] for i in range(1, len(vals)) if vals[i - 1] > 0]
|
||||
if not rets:
|
||||
return 0.0
|
||||
mean = sum(rets) / len(rets)
|
||||
std = (sum((r - mean) ** 2 for r in rets) / max(len(rets) - 1, 1)) ** 0.5
|
||||
return mean / std * np.sqrt(365 * 24) if std > 0 else 0.0
|
||||
|
||||
@property
|
||||
def consistency(self) -> float:
|
||||
"""Fraction of windows with positive OOS Sharpe."""
|
||||
if not self.windows:
|
||||
return 0.0
|
||||
positive = sum(1 for w in self.windows if w.oos_sharpe > 0)
|
||||
return positive / len(self.windows)
|
||||
|
||||
@property
|
||||
def avg_oos_sharpe(self) -> float:
|
||||
if not self.windows:
|
||||
return 0.0
|
||||
return sum(w.oos_sharpe for w in self.windows) / len(self.windows)
|
||||
|
||||
@property
|
||||
def performance_decay(self) -> float:
|
||||
"""IS Sharpe → OOS decay ratio. <1 = decay, >1 = improvement (rare)."""
|
||||
avg_is = sum(w.is_sharpe for w in self.windows) / max(len(self.windows), 1)
|
||||
avg_oos = self.avg_oos_sharpe
|
||||
return avg_oos / avg_is if avg_is != 0 else 0.0
|
||||
|
||||
@property
|
||||
def total_oos_trades(self) -> int:
|
||||
return sum(w.oos_trades for w in self.windows)
|
||||
|
||||
def significance_report(self, n_trials: int = 639) -> dict:
|
||||
return QuantVerdict(
|
||||
observed_sharpe=self.oos_sharpe,
|
||||
wf_consistency=self.consistency,
|
||||
n_trials=n_trials,
|
||||
n_periods=max(self.total_oos_trades, 1),
|
||||
positive_regimes=0,
|
||||
).evaluate()
|
||||
|
||||
def summary(self) -> dict:
|
||||
return {
|
||||
"strategy": self.strategy,
|
||||
"interval": self.interval,
|
||||
"n_windows": self.n_windows,
|
||||
"consistency": round(self.consistency, 3),
|
||||
"oos_sharpe": round(self.oos_sharpe, 3),
|
||||
"avg_oos_sharpe": round(self.avg_oos_sharpe, 3),
|
||||
"performance_decay": round(self.performance_decay, 3),
|
||||
"total_oos_trades": self.total_oos_trades,
|
||||
"verdict": self.significance_report()["verdict"],
|
||||
}
|
||||
|
||||
|
||||
class WalkForwardRunner:
|
||||
"""Run walk-forward validation using VBT runner on historical data."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
n_windows: int = 5,
|
||||
bar_limits: list[int] | None = None,
|
||||
fee_tier: int = 0,
|
||||
staking_tier: str = "none",
|
||||
):
|
||||
self._n_windows = n_windows
|
||||
self._bar_limits = bar_limits or [100, 200, 500, 1000, 2000]
|
||||
self._fee_tier = fee_tier
|
||||
self._staking_tier = staking_tier
|
||||
|
||||
def run(
|
||||
self,
|
||||
strategy: str,
|
||||
interval: str = "1h",
|
||||
coin: str = "BTC",
|
||||
testnet: bool = False,
|
||||
) -> WFReport:
|
||||
"""Execute walk-forward validation on real Hyperliquid data.
|
||||
|
||||
Uses HyperliquidDataProvider to fetch candle data, then splits
|
||||
into sequential IS/OOS windows. For each window:
|
||||
1. Optimize bar limit on IS data (pick best by Sharpe)
|
||||
2. Test the optimal bar limit on OOS data
|
||||
3. Record IS/OOS Sharpe, returns, trades
|
||||
"""
|
||||
from framework.data import HyperliquidDataProvider
|
||||
from backtests.vbt_runner import VBTBacktestRunner
|
||||
|
||||
provider = HyperliquidDataProvider(testnet=testnet)
|
||||
|
||||
# Fetch maximum data needed
|
||||
max_bars = max(self._bar_limits) * (self._n_windows + 1)
|
||||
df = provider.fetch_candles(coin, interval=interval, limit=max_bars)
|
||||
|
||||
if df.empty or len(df) < 100:
|
||||
return WFReport(strategy=strategy, interval=interval, n_windows=self._n_windows)
|
||||
|
||||
total_bars = len(df)
|
||||
window_size = total_bars // (self._n_windows + 1)
|
||||
if window_size < 50:
|
||||
return WFReport(strategy=strategy, interval=interval, n_windows=self._n_windows)
|
||||
|
||||
report = WFReport(strategy=strategy, interval=interval, n_windows=self._n_windows)
|
||||
cumulative_oos_equity = 10000.0
|
||||
report.oos_equity_curve.append({"t": 0, "v": cumulative_oos_equity})
|
||||
|
||||
for w in range(self._n_windows):
|
||||
is_start_idx = w * window_size
|
||||
is_end_idx = is_start_idx + window_size
|
||||
oos_start_idx = is_end_idx
|
||||
oos_end_idx = min(oos_start_idx + window_size, total_bars)
|
||||
|
||||
is_start_ts = str(df.index[is_start_idx])[:10]
|
||||
is_end_ts = str(df.index[min(is_end_idx - 1, total_bars - 1)])[:10]
|
||||
oos_start_ts = str(df.index[min(oos_start_idx, total_bars - 1)])[:10]
|
||||
oos_end_ts = str(df.index[min(oos_end_idx - 1, total_bars - 1)])[:10]
|
||||
|
||||
# Convert dates to ms for HL API
|
||||
is_start_ms = int(df.index[is_start_idx].timestamp() * 1000)
|
||||
is_end_ms = int(df.index[min(is_end_idx - 1, total_bars - 1)].timestamp() * 1000)
|
||||
oos_start_ms = int(df.index[min(oos_start_idx, total_bars - 1)].timestamp() * 1000)
|
||||
oos_end_ms = int(df.index[min(oos_end_idx - 1, total_bars - 1)].timestamp() * 1000)
|
||||
|
||||
# IN-SAMPLE: optimize bar limit
|
||||
best_limit = self._bar_limits[0]
|
||||
best_is_sharpe = -999.0
|
||||
best_is_return = 0.0
|
||||
|
||||
for limit in self._bar_limits:
|
||||
is_bars = min(limit, window_size)
|
||||
try:
|
||||
runner = VBTBacktestRunner(
|
||||
vip_tier=self._fee_tier, staking_tier=self._staking_tier
|
||||
)
|
||||
result = runner.run_strategy(
|
||||
strategy=strategy, interval=interval, testnet=testnet,
|
||||
limit=is_bars, start_ms=is_start_ms, end_ms=is_end_ms,
|
||||
)
|
||||
if result and result.get("sharpe", -999) > best_is_sharpe:
|
||||
best_is_sharpe = result.get("sharpe", -999)
|
||||
best_is_return = result.get("total_return_pct", 0)
|
||||
best_limit = limit
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# OUT-OF-SAMPLE: test the best bar limit
|
||||
if best_is_sharpe <= -998:
|
||||
continue
|
||||
|
||||
oos_bars = min(best_limit, oos_end_idx - oos_start_idx)
|
||||
try:
|
||||
runner = VBTBacktestRunner(
|
||||
vip_tier=self._fee_tier, staking_tier=self._staking_tier
|
||||
)
|
||||
oos_result = runner.run_strategy(
|
||||
strategy=strategy, interval=interval, testnet=testnet,
|
||||
limit=oos_bars, start_ms=oos_start_ms, end_ms=oos_end_ms,
|
||||
)
|
||||
if oos_result:
|
||||
oos_sharpe = oos_result.get("sharpe", 0)
|
||||
oos_return = oos_result.get("total_return_pct", 0)
|
||||
oos_trades = len(oos_result.get("trades", []))
|
||||
|
||||
cumulative_oos_equity += cumulative_oos_equity * oos_return / 100.0
|
||||
report.oos_equity_curve.append({
|
||||
"t": w + 1,
|
||||
"v": round(cumulative_oos_equity, 2),
|
||||
})
|
||||
|
||||
report.windows.append(WFWindow(
|
||||
window_idx=w,
|
||||
is_start=is_start_ts, is_end=is_end_ts,
|
||||
oos_start=oos_start_ts, oos_end=oos_end_ts,
|
||||
is_sharpe=round(best_is_sharpe, 3),
|
||||
oos_sharpe=round(oos_sharpe, 3),
|
||||
is_return_pct=round(best_is_return, 2),
|
||||
oos_return_pct=round(oos_return, 2),
|
||||
oos_trades=oos_trades,
|
||||
best_params={"limit": best_limit},
|
||||
))
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return report
|
||||
|
||||
|
||||
# ── Quick validation ────────────────────────────────────────
|
||||
|
||||
def quick_validate(strategy: str, interval: str = "1h", **kwargs) -> dict:
|
||||
"""Run walk-forward and return significance report in one call."""
|
||||
wfr = WalkForwardRunner(**kwargs)
|
||||
report = wfr.run(strategy=strategy, interval=interval)
|
||||
return report.summary()
|
||||
Reference in New Issue
Block a user