quantKonwledge/07_回测框架/回测方法论与实践.md

# 回测方法论与实践

> 回测是量化交易策略开发中最关键的环节。本文档详细介绍回测的正确方法、常见偏差的规避技巧，以及主要绩效评估指标的计算与解读。

---

## 一、回测的核心原则

### 1.1 什么是好的回测

一个可靠的回测应满足以下条件：

- **无未来数据泄露**：策略在任何时刻只能使用该时刻之前的数据
- **包含真实交易成本**：手续费、滑点、借贷成本
- **样本外验证**：在从未用于优化的数据上测试
- **多市场验证**：在不同市场条件下均表现稳定
- **统计显著性**：足够多的交易次数，避免小样本偏差

### 1.2 回测流程

```
1. 策略假设定义
      ↓
2. 历史数据准备（清洗、验证）
      ↓
3. 样本内回测（In-Sample，用于参数优化）
      ↓
4. 样本外验证（Out-of-Sample，评估真实表现）
      ↓
5. 前向测试（Walk-Forward，模拟实盘）
      ↓
6. 纸面交易（Paper Trading，实时验证）
      ↓
7. 小资金实盘（逐步增加资金）
```

---

## 二、常见回测偏差

### 2.1 过拟合偏差（Overfitting Bias）

**定义**：策略参数过度优化，在历史数据上表现完美，但在新数据上失效。

**识别方法**：
- 样本内夏普比率远高于样本外（> 2 倍差距）
- 策略参数过多（自由度过高）
- 参数微小变化导致绩效大幅波动

**规避方法**：
- 使用奥卡姆剃刀原则：简单策略优于复杂策略
- 参数敏感性测试：参数在合理范围内变化时，绩效应相对稳定
- 交叉验证：将数据分为多个折叠，分别测试

### 2.2 数据窥探偏差（Data Snooping Bias）

**定义**：在同一数据集上反复测试多个策略，直到找到"有效"的策略。

**规避方法**：
- 严格区分样本内和样本外数据
- 使用 Bonferroni 校正调整多重检验的显著性水平
- 预先注册策略假设（Pre-registration）

### 2.3 幸存者偏差（Survivorship Bias）

**定义**：历史数据只包含至今仍存在的资产，已退市或破产的资产被排除。

**加密货币中的体现**：
- 许多山寀币已归零，但历史数据库可能不包含这些数据
- 只看当前主流币的历史表现，会高估策略收益

**规避方法**：
- 使用包含退市资产的完整数据集
- 在策略中加入资产筛选机制（如市值门槛）

### 2.4 未来数据泄露（Look-Ahead Bias）

**定义**：在计算指标时，使用了当时不可能获得的未来数据。

**常见错误**：
```python
# 错误示例：使用当天最高价计算信号（当天收盘前不知道最高价）
signal = df['high'].rolling(20).max()  # 错误！

# 正确示例：使用前一天的最高价
signal = df['high'].shift(1).rolling(20).max()  # 正确
```

**tradehk 的处理**：信号在 K 线收盘后计算，下一根 K 线开盘时执行，避免了未来数据泄露。

### 2.5 交易成本忽略（Transaction Cost Neglect）

**加密货币交易成本构成**：

| 成本类型 | 典型值 | 说明 |
|----------|--------|------|
| Maker 手续费 | 0.02-0.05% | 挂限价单 |
| Taker 手续费 | 0.04-0.1% | 吃市价单 |
| 滑点 | 0.01-0.5% | 取决于流动性和订单大小 |
| 资金费率 | ±0.01%/8h | 永续合约持仓成本 |

**回测中的处理**：
```python
# 建议在回测中使用略高于实际的手续费，留出安全边际
COMMISSION_RATE = 0.001  # 0.1%（含滑点）

def calculate_pnl(entry_price, exit_price, side, size):
    if side == 'LONG':
        gross_pnl = (exit_price - entry_price) * size
    else:
        gross_pnl = (entry_price - exit_price) * size
    
    # 扣除双边手续费
    commission = (entry_price + exit_price) * size * COMMISSION_RATE
    return gross_pnl - commission
```

---

## 三、绩效评估指标

### 3.1 收益类指标

**总收益率（Total Return）**：
$$R_{total} = \frac{最终净值 - 初始资金}{初始资金} \times 100\%$$

**年化收益率（CAGR）**：
$$CAGR = \left(\frac{最终净值}{初始资金}\right)^{\frac{1}{年数}} - 1$$

### 3.2 风险调整收益指标

**夏普比率（Sharpe Ratio）**：
$$Sharpe = \frac{年化收益率 - 无风险利率}{年化波动率}$$

| 夏普比率 | 评级 |
|----------|------|
| < 0 | 不可接受 |
| 0-0.5 | 较差 |
| 0.5-1.0 | 一般 |
| 1.0-2.0 | 良好 |
| > 2.0 | 优秀 |

**索提诺比率（Sortino Ratio）**：只考虑下行波动率，更适合非对称收益分布：
$$Sortino = \frac{年化收益率 - 无风险利率}{下行波动率}$$

**卡尔玛比率（Calmar Ratio）**：
$$Calmar = \frac{年化收益率}{最大回撤}$$

### 3.3 风险类指标

**最大回撤（Maximum Drawdown）**：
$$MDD = \max_{t \in [0,T]} \left(\frac{峰值净值 - 当前净值}{峰值净值}\right)$$

**回撤持续时间**：从峰值到恢复峰值所需的时间，越短越好。

**VaR（风险价值）**：在给定置信水平下，未来某时间段内可能发生的最大损失。

### 3.4 交易质量指标

| 指标 | 计算方法 | 目标值 |
|------|----------|--------|
| 胜率 | 盈利交易数 / 总交易数 | > 50%（趋势策略可低于 50%） |
| 盈亏比 | 平均盈利 / 平均亏损 | > 1.5 |
| 期望值 | 胜率 × 盈亏比 - (1 - 胜率) | > 0 |
| 最大连续亏损 | 连续亏损的最大次数 | 越小越好 |

---

## 四、Python 回测框架

### 4.1 主流回测库对比

| 框架 | 特点 | 适用场景 |
|------|------|----------|
| Backtrader | 功能全面，文档丰富 | 股票、期货 |
| Backtesting.py | 简洁易用，可视化好 | 快速原型 |
| QuantConnect | 云端，支持多资产 | 专业量化 |
| Freqtrade | 专为加密货币设计 | 加密货币 |
| VectorBT | 向量化，速度极快 | 大规模回测 |

### 4.2 简单回测框架实现

```python
import pandas as pd
import numpy as np
from dataclasses import dataclass
from typing import List, Optional

@dataclass
class Trade:
    entry_time: pd.Timestamp
    exit_time: Optional[pd.Timestamp]
    side: str  # 'LONG' or 'SHORT'
    entry_price: float
    exit_price: Optional[float]
    size: float
    pnl: Optional[float] = None

class SimpleBacktester:
    def __init__(self, initial_capital: float = 10000, commission: float = 0.001):
        self.initial_capital = initial_capital
        self.commission = commission
        self.capital = initial_capital
        self.trades: List[Trade] = []
        self.equity_curve = []
    
    def run(self, df: pd.DataFrame, signals: pd.Series) -> dict:
        """
        df: K 线数据（含 OHLCV）
        signals: 信号序列（1=买入，-1=卖出，0=持仓）
        """
        position = 0
        current_trade = None
        
        for i, (timestamp, row) in enumerate(df.iterrows()):
            signal = signals.iloc[i]
            
            # 开多仓
            if signal == 1 and position == 0:
                size = self.capital / row['close']
                cost = row['close'] * size * self.commission
                self.capital -= cost
                position = 1
                current_trade = Trade(
                    entry_time=timestamp,
                    exit_time=None,
                    side='LONG',
                    entry_price=row['close'],
                    exit_price=None,
                    size=size
                )
            
            # 平多仓
            elif signal == -1 and position == 1:
                revenue = row['close'] * current_trade.size
                cost = revenue * self.commission
                pnl = (row['close'] - current_trade.entry_price) * current_trade.size - cost
                self.capital += revenue - cost
                
                current_trade.exit_time = timestamp
                current_trade.exit_price = row['close']
                current_trade.pnl = pnl
                self.trades.append(current_trade)
                position = 0
                current_trade = None
            
            # 记录净值曲线
            if position == 1 and current_trade:
                unrealized_pnl = (row['close'] - current_trade.entry_price) * current_trade.size
                self.equity_curve.append(self.capital + unrealized_pnl)
            else:
                self.equity_curve.append(self.capital)
        
        return self.calculate_metrics()
    
    def calculate_metrics(self) -> dict:
        equity = pd.Series(self.equity_curve)
        returns = equity.pct_change().dropna()
        
        total_return = (equity.iloc[-1] / self.initial_capital - 1) * 100
        max_drawdown = ((equity.cummax() - equity) / equity.cummax()).max() * 100
        sharpe = returns.mean() / returns.std() * np.sqrt(365 * 24)  # 小时级别
        
        winning_trades = [t for t in self.trades if t.pnl and t.pnl > 0]
        win_rate = len(winning_trades) / len(self.trades) if self.trades else 0
        
        return {
            '总收益率': f"{total_return:.2f}%",
            '最大回撤': f"{max_drawdown:.2f}%",
            '夏普比率': f"{sharpe:.2f}",
            '胜率': f"{win_rate:.2%}",
            '总交易次数': len(self.trades),
            '最终资金': f"${self.capital:.2f}"
        }
```

---

## 五、前向测试（Walk-Forward Analysis）

前向测试是最接近实盘的回测方法，通过滚动窗口模拟参数定期重新优化的过程：

```
时间轴：|---训练期---|---测试期---|---训练期---|---测试期---|
         窗口 1                   窗口 2

流程：
1. 在训练期内优化参数
2. 用优化后的参数在测试期内运行策略
3. 滚动到下一个窗口
4. 汇总所有测试期的绩效
```

---

## 参考资料

- QuantStart. "Backtesting Systematic Trading Strategies in Python". https://www.quantstart.com/
- Backtesting.py 文档：https://kernc.github.io/backtesting.py/
- BigQuant 量化平台：https://bigquant.com/