12.2 The Science of Backtesting

1import numpy as np
2import pandas as pd
3
4def calculate_performance_metrics(returns, risk_free_rate=0.0):
5    """
6    Calculates annualized performance metrics for a return series.
7    """
8    # Annualization factor assuming daily returns
9    ann_factor = 252
10    
11    # Calculate expected excess returns
12    excess_returns = returns - (risk_free_rate / ann_factor)
13    mean_return = np.mean(excess_returns) * ann_factor
14    
15    # Standard deviation (Total Volatility)
16    volatility = np.std(excess_returns, ddof=1) * np.sqrt(ann_factor)
17    
18    # Downside deviation
19    downside_returns = excess_returns[excess_returns < 0]
20    downside_vol = np.std(downside_returns, ddof=1) * np.sqrt(ann_factor) if len(downside_returns) > 0 else 1e-6
21    
22    # Sharpe & Sortino Ratios
23    sharpe_ratio = mean_return / volatility if volatility > 0 else 0.0
24    sortino_ratio = mean_return / downside_vol if downside_vol > 0 else 0.0
25    
26    # Drawdown Calculation
27    cum_returns = np.exp(np.cumsum(returns))
28    running_max = np.maximum.accumulate(cum_returns)
29    drawdowns = (cum_returns - running_max) / running_max
30    max_drawdown = np.min(drawdowns)
31    
32    # Calmar Ratio
33    calmar_ratio = mean_return / abs(max_drawdown) if abs(max_drawdown) > 0 else 0.0
34    
35    return {
36        "Annualized Return": mean_return,
37        "Annualized Volatility": volatility,
38        "Sharpe Ratio": sharpe_ratio,
39        "Sortino Ratio": sortino_ratio,
40        "Max Drawdown": max_drawdown,
41        "Calmar Ratio": calmar_ratio
42    }
43
44def run_monte_carlo_simulation(returns, initial_capital=100000, num_simulations=10000, ruin_threshold=0.50):
45    """
46    Runs a bootstrap Monte Carlo simulation to determine drawdown distributions and probability of ruin.
47    """
48    num_trades = len(returns)
49    simulated_drawdowns = []
50    ruin_count = 0
51    
52    # Pre-allocate array for speed
53    sim_paths = np.random.choice(returns, size=(num_trades, num_simulations), replace=True)
54    
55    for sim in range(num_simulations):
56        path_returns = sim_paths[:, sim]
57        cum_equity = initial_capital * np.exp(np.cumsum(path_returns))
58        
59        # Peak to trough calculation
60        running_max = np.maximum.accumulate(cum_equity)
61        drawdowns = (cum_equity - running_max) / running_max
62        max_dd = np.min(drawdowns)
63        simulated_drawdowns.append(max_dd)
64        
65        # Check for ruin
66        if abs(max_dd) >= ruin_threshold:
67            ruin_count += 1
68            
69    prob_of_ruin = ruin_count / num_simulations
70    median_max_drawdown = np.median(simulated_drawdowns)
71    percentile_95_drawdown = np.percentile(simulated_drawdowns, 5) # 5th percentile is the worst 5% drawdown
72    
73    return {
74        "Probability of Ruin": prob_of_ruin,
75        "Median Max Drawdown": median_max_drawdown,
76        "95th Percentile Drawdown": percentile_95_drawdown
77    }
78
79# --- Example Usage ---
80if __name__ == "__main__":
81    # Seed for reproducibility
82    np.random.seed(42)
83    
84    # Generate synthetic daily returns for a strategy with an edge
85    # Mean return of 0.05% daily, 1.2% daily volatility (standard deviations)
86    synthetic_returns = np.random.normal(loc=0.0005, scale=0.012, size=1000)
87    
88    # Calculate Performance Metrics
89    metrics = calculate_performance_metrics(synthetic_returns)
90    print("--- Strategy Performance Metrics ---")
91    for k, v in metrics.items():
92        print(f"{k}: {v:.4f}")
93        
94    # Run Monte Carlo stress testing
95    mc_results = run_monte_carlo_simulation(synthetic_returns, ruin_threshold=0.20)
96    print("\n--- Monte Carlo Stress Test (Ruin Threshold: 20% Drawdown) ---")
97    for k, v in mc_results.items():
98        print(f"{k}: {v:.4f}")