Walk-Forward Trading Strategy Optimization System

Development of Walk-Forward Trading Strategy Optimization System

Walk-Forward Optimization (WFO) — methodology for assessing trading strategy robustness. Unlike traditional backtesting, WFO simulates real-world application: parameters are optimized on one period, tested on the next, then everything shifts forward. This minimizes overfitting to historical data.

Why Ordinary Backtest is Insufficient

Problem of Curve Fitting: Optimizing strategy parameters (moving averages, RSI period, stop-loss) on entire history, we get parameters perfectly suited for the past. But markets change: optimal parameters from 2015-2018 may not be good for 2021-2024.

Walk-Forward Solves This:

| In-Sample (IS) | Out-of-Sample (OOS) |
|                |--IS--|   OOS   |
|                       |--IS--|   OOS  |
|                                 |--IS--|  OOS  |

Each OOS-period — independent assessment on data the model "didn't see" during optimization.

Walk-Forward Scheme Parameters

Anchored vs. Rolling:

• Anchored (expanding window): IS always starts from one date, expands
• Rolling (sliding window): Fixed-size IS window shifts

Rolling preferred: strategy adapts to changing market, old data doesn't interfere.

Efficiency Ratio:

WFE (Walk-Forward Efficiency) = OOS_Return / IS_Return

Ideally: WFE > 0.7. WFE < 0.3 → strong overfitting, strategy doesn't work.

Anchor Periods:

• IS: 2-4 years of data
• OOS: 3-6 months
• Number of iterations: 8-20 (depends on history length)

Optimization Process

Parameter Space:

param_space = {
    'fast_ma': range(5, 50, 5),
    'slow_ma': range(20, 200, 10),
    'rsi_period': range(7, 28, 1),
    'stop_loss_atr': [1.0, 1.5, 2.0, 2.5, 3.0],
    'position_size': [0.01, 0.02, 0.03]
}
# Total combinations: ~50,000+

Search Methods:

• Grid Search: full enumeration, computationally expensive
• Random Search: random sampling, more efficient with large space
• Bayesian Optimization (Optuna): considers history of evaluations, 10-50× more efficient than grid

Objective Function: Not just Return. Preferred metrics for optimization:

• Sharpe Ratio: return / volatility
• Calmar Ratio: annual return / max drawdown
• Sortino Ratio: return / downside deviation
• Profit Factor: gross profit / gross loss

Robustness and Statistical Significance

Monte Carlo Permutation Test:

def permutation_test(returns, n_permutations=1000):
    """Check: is result better than random trading?"""
    original_sharpe = compute_sharpe(returns)
    random_sharpes = []

    for _ in range(n_permutations):
        shuffled = np.random.permutation(returns)
        random_sharpes.append(compute_sharpe(shuffled))

    p_value = np.mean(np.array(random_sharpes) >= original_sharpe)
    return p_value  # p < 0.05 → statistically significant

Combinatorial Purged Cross-Validation (CPCV): From Marcos Lopez de Prado's book. Generates 2^(k-1) different backtest paths — provides distribution of results, not single backtesting path.

Distribution of OOS Results: Build distribution of Sharpe ratio across all WFO iterations. If median > 0.5 and < 10% of iterations are unprofitable — strategy is robust.

Parameter Stability

Robust strategy should work with small parameter changes:

def parameter_sensitivity(strategy, optimal_params, perturbation=0.1):
    """3D heatmap of results at ±10% from optimal parameters"""
    results = {}
    for p_a in np.linspace(0.9, 1.1, 5):
        for p_b in np.linspace(0.9, 1.1, 5):
            perturbed_params = {
                'fast_ma': int(optimal_params['fast_ma'] * p_a),
                'slow_ma': int(optimal_params['slow_ma'] * p_b)
            }
            results[(p_a, p_b)] = backtest_sharpe(strategy, perturbed_params)
    return results

"Flat plateau" around optimum → strategy is robust. Sharp peak → overfitting.

Production Pipeline

Automated Re-optimization: Every 3 months:

1. Fetch new data
2. Run WFO on expanded IS window
3. If OOS metrics within normal range → use new parameters
4. If degradation > 20% → signal for manual review

Strategy Versioning: MLflow or Git to store each version: parameters, IS/OOS metrics, application date.

Timeline: WFO framework implementation for one strategy with Optuna — 3-4 weeks. Full system with CPCV, Monte Carlo tests and auto re-optimization — 8-10 weeks.