跳转至

第12章 参数优化

本章介绍 Lean 的参数优化功能,包括网格搜索、优化策略和结果分析。

12.1 优化概述

12.1.1 什么是参数优化?

参数优化是系统性地测试不同参数组合,找到最优参数的过程。

12.1.2 优化目标

常见的优化目标: - Sharpe Ratio:风险调整后收益 - Total Return:总收益 - Sortino Ratio:下行风险调整收益 - Drawdown:控制最大回撤 - Win Rate:胜率 - Profit-Loss Ratio:盈亏比

12.2 使用 Lean CLI 优化

12.2.1 优化配置文件

Lean CLI 没有 lean optimize create 子命令。参数空间直接定义在项目目录下的 optimization.json 文件中(结构与引擎优化器配置 Optimizer.Launcher/config.example.json 同源),运行 lean optimize "项目名" 时会读取该文件。

12.2.2 optimization.json 格式

{
  // 优化目标:从回测输出 JSON 中取值
  "optimization-criterion": {
    "target": "Statistics.Sharpe Ratio",
    "extremum": "max"
  },

  // 约束条件:不满足约束的回测结果会被丢弃
  // operator 可选:less, lessOrEqual, greater, greaterOrEqual, equals, notEqual
  "constraints": [
    {
      "target": "Drawdown",
      "operator": "lessOrEqual",
      "target-value": 0.15
    }
  ],

  // 最大并发回测数(可选,默认为 CPU 核数 / 2)
  "maximum-concurrent-backtests": 4,

  // 优化参数
  "parameters": [
    {
      "name": "fastPeriod",
      "min": 10,
      "max": 50,
      "step": 5
    },
    {
      "name": "slowPeriod",
      "min": 30,
      "max": 70,
      "step": 10
    }
  ]
}

12.2.3 运行优化

# 运行优化(读取项目目录下的 optimization.json)
lean optimize "MyStrategy"

# 指定最大并发回测数
lean optimize "MyStrategy" --max-concurrent-backtests 8

# 使用云端优化
lean cloud optimize "MyStrategy"

12.3 参数化策略

12.3.1 策略参数定义

from AlgorithmImports import *

class ParameterizedStrategy(QCAlgorithm):
    """
    可参数化的策略
    """

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol

        # ========== 可优化参数 ==========

        # 从参数或默认值获取(GetParameter 返回 str,需转换为数值)
        self.fast_period = int(self.GetParameter("fastPeriod") or 20)
        self.slow_period = int(self.GetParameter("slowPeriod") or 50)
        self.rsi_period = int(self.GetParameter("rsiPeriod") or 14)
        self.rsi_oversold = int(self.GetParameter("rsiOversold") or 30)
        self.rsi_overbought = int(self.GetParameter("rsiOverbought") or 70)

        # 创建指标
        self.sma_fast = self.SMA(self.spy, self.fast_period)
        self.sma_slow = self.SMA(self.spy, self.slow_period)
        self.rsi = self.RSI(self.spy, self.rsi_period)

        self.SetWarmUp(TimeSpan.FromDays(max(self.slow_period, self.rsi_period) + 10))

        # 输出参数
        self.Debug(f"Parameters: Fast={self.fast_period}, Slow={self.slow_period}, "
                  f"RSI Period={self.rsi_period}, Oversold={self.rsi_oversold}, "
                  f"Overbought={self.rsi_overbought}")

    def OnData(self, data):
        if not self.sma_fast.IsReady or not self.rsi.IsReady:
            return

        fast = self.sma_fast.Current.Value
        slow = self.sma_slow.Current.Value
        rsi = self.rsi.Current.Value

        # 使用参数化的阈值
        if fast > slow and rsi < self.rsi_oversold:
            if not self.Portfolio[self.spy].IsLong:
                self.SetHoldings(self.spy, 1)
        elif fast < slow or rsi > self.rsi_overbought:
            if self.Portfolio[self.spy].IsLong:
                self.Liquidate(self.spy)

12.3.2 参数约束

def ValidateParameters(self):
    """验证参数有效性"""

    # 确保快线周期小于慢线
    if self.fast_period >= self.slow_period:
        self.Error(f"Invalid parameters: fast ({self.fast_period}) >= slow ({self.slow_period})")
        return False

    # 确保阈值在合理范围
    if self.rsi_oversold >= self.rsi_overbought:
        self.Error(f"Invalid thresholds: oversold >= overbought")
        return False

    return True

def Initialize(self):
    # ... 参数设置 ...

    if not self.ValidateParameters():
        self.Quit("Invalid parameters")

12.4 优化策略

12.4.1 网格搜索

网格搜索是最常用的优化方法,遍历所有参数组合:

# 配置示例
{
  "parameters": [
    {
      "name": "fastPeriod",
      "min": 5,
      "max": 25,
      "step": 5
    }
  ]
}

# 将测试:5, 10, 15, 20, 25
# 总共 5 个值

12.4.2 自适应优化

class AdaptiveOptimizationStrategy(QCAlgorithm):
    """
    自适应优化策略

    根据市场状态动态调整参数
    """

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol

        # 基础参数
        self.base_fast_period = 20
        self.base_slow_period = 50

        # 市场状态指标
        self.atr = self.ATR(self.spy, 14)
        self.vix = self.AddEquity("VIX", Resolution.Daily).Symbol

        self.SetWarmUp(TimeSpan.FromDays(60))

        # 调度:每月重新计算参数
        self.Schedule.On(
            self.DateRules.MonthStart(),
            self.TimeRules.AfterMarketOpen(self.spy, 30),
            self.AdjustParameters
        )

    def AdjustParameters(self):
        """根据市场状态调整参数"""

        # 获取市场波动率
        volatility = self.atr.Current.Value / self.Securities[self.spy].Price

        # 根据 VIX 调整均线周期
        vix_level = self.Securities[self.vix].Price

        if vix_level > 25:  # 高波动
            # 使用更快的参数
            self.fast_period = int(self.base_fast_period * 0.7)
            self.slow_period = int(self.base_slow_period * 0.8)
        elif vix_level < 15:  # 低波动
            # 使用更慢的参数
            self.fast_period = int(self.base_fast_period * 1.3)
            self.slow_period = int(self.base_slow_period * 1.2)
        else:  # 正常波动
            self.fast_period = self.base_fast_period
            self.slow_period = self.base_slow_period

        # 重建指标
        self.sma_fast = self.SMA(self.spy, self.fast_period)
        self.sma_slow = self.SMA(self.spy, self.slow_period)

        self.Debug(f"Adjusted parameters: Fast={self.fast_period}, "
                  f"Slow={self.slow_period}, VIX={vix_level:.2f}")

12.5 过拟合避免

12.5.1 过拟合的迹象

迹象 说明
参数过多 参数数量相对于数据量过多
极高夏普比率 回测夏普比率异常高(>5)
交易次数少 策略交易次数过少
复杂规则 规则过于复杂难以解释
样本内表现好 样本内好但样本外差

12.5.2 防止过拟合的方法

class RobustOptimizationStrategy(QCAlgorithm):
    """
    防止过拟合的优化策略
    """

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol

        # 1. 使用简单参数
        self.fast_period = 20
        self.slow_period = 50

        # 2. 限制参数范围
        self.fast_period = max(5, min(self.fast_period, 50))
        self.slow_period = max(20, min(self.slow_period, 200))

        # 3. 确保参数差异足够大
        if self.slow_period / self.fast_period < 2:
            self.slow_period = self.fast_period * 2

        # 4. 使用简化逻辑
        self.sma_fast = self.SMA(self.spy, self.fast_period)
        self.sma_slow = self.SMA(self.spy, self.slow_period)

        self.SetWarmUp(TimeSpan.FromDays(self.slow_period + 10))

        # 5. 记录交易次数
        self.trade_count = 0

    def OnData(self, data):
        # 6. 限制交易频率
        if self.trade_count > 100:  # 最大100笔交易
            return

        # 简单的交易逻辑
        if self.sma_fast.Current.Value > self.sma_slow.Current.Value:
            if not self.Portfolio[self.spy].IsLong:
                self.SetHoldings(self.spy, 1)
                self.trade_count += 1
        else:
            if self.Portfolio[self.spy].IsLong:
                self.Liquidate(self.spy)
                self.trade_count += 1

    def OnEndOfAlgorithm(self):
        # 7. 输出关键统计
        sharpe = self.Statistics.TotalPerformance.PortfolioStatistics.SharpeRatio
        self.Debug(f"Total trades: {self.trade_count}")
        self.Debug(f"Sharpe Ratio: {sharpe:.2f}")

        # 8. 警告可能过拟合
        if sharpe > 3:
            self.Log("High Sharpe Ratio - possible overfitting!")
        if self.trade_count < 20:
            self.Log("Low trade count - results may not be significant!")

12.6 多目标优化

12.6.1 综合评分函数

class MultiObjectiveOptimization(QCAlgorithm):
    """
    多目标优化策略

    同时考虑多个目标
    """

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        # Portfolio 没有 StartingCash 属性,在此保存初始资金
        self.starting_cash = self.Portfolio.TotalPortfolioValue

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol
        self.sma_fast = self.SMA(self.spy, 20)
        self.sma_slow = self.SMA(self.spy, 50)

        self.SetWarmUp(TimeSpan.FromDays(60))

        # 记录指标
        self.returns = []
        self.drawdowns = []

    def OnData(self, data):
        if not self.sma_fast.IsReady:
            return

        # 记录每日组合价值和回撤
        current_value = self.Portfolio.TotalPortfolioValue
        self.returns.append(current_value)

        # 计算当前回撤
        if len(self.returns) > 1:
            peak = max(self.returns)
            drawdown = (current_value - peak) / peak
            self.drawdowns.append(drawdown)

        # 交易逻辑
        if self.sma_fast.Current.Value > self.sma_slow.Current.Value:
            if not self.Portfolio[self.spy].IsLong:
                self.SetHoldings(self.spy, 1)
        else:
            if self.Portfolio[self.spy].IsLong:
                self.Liquidate(self.spy)

    def CalculateCompositeScore(self):
        """
        计算综合评分

        考虑:
        - 总收益 (40%)
        - 夏普比率 (30%)
        - 最大回撤 (20%)
        - 交易次数 (10%)
        """
        # 总收益
        total_return = (self.Portfolio.TotalPortfolioValue /
                       self.starting_cash - 1)

        # 夏普比率
        if len(self.returns) > 1:
            returns_array = list(pd.Series(self.returns).pct_change().dropna())
            sharpe = (np.mean(returns_array) / np.std(returns_array) * np.sqrt(252)
                       if np.std(returns_array) > 0 else 0)
        else:
            sharpe = 0

        # 最大回撤
        max_dd = min(self.drawdowns) if self.drawdowns else 0

        # 交易次数惩罚(交易太多会降低分数)
        # Summary 是字典,订单数需从 Summary["Total Orders"] 读取
        trade_count = int(self.Statistics.Summary["Total Orders"])
        trade_penalty = max(0, 1 - (trade_count - 50) / 100)

        # 计算各部分得分
        return_score = min(total_return * 2, 1)  # 最高100%收益得满分
        sharpe_score = min(sharpe / 2, 1)  # 夏普2得满分
        drawdown_score = max(0, 1 + max_dd * 5)  # 回撤20%得0分

        # 综合评分
        composite = (return_score * 0.4 +
                     sharpe_score * 0.3 +
                     drawdown_score * 0.2 +
                     trade_penalty * 0.1)

        return composite

    def OnEndOfAlgorithm(self):
        score = self.CalculateCompositeScore()
        self.Debug(f"\nComposite Score: {score:.3f}")
        self.Debug(f"Components: Return, Sharpe, Drawdown, Trades")

12.7 优化结果分析

12.7.1 查看优化结果

lean optimize 没有 results 子命令。优化完成后,结果直接写入项目目录下的 optimizations/<时间戳>/ 文件夹,其中包含每次参数组合回测的结果 JSON 和日志:

# 查看历次优化结果目录
ls "MyStrategy/optimizations"

# 查看最新一次优化的结果文件
ls "MyStrategy/optimizations/2023-01-01_12-00-00"

12.7.2 参数敏感性分析

# 分析参数变化对结果的影响

def AnalyzeParameterSensitivity(results_df):
    """
    分析参数敏感性

    Args:
        results_df: 包含参数和结果的数据框
    """
    # 按参数分组分析
    param_results = {}

    for param in ['fastPeriod', 'slowPeriod']:
        param_results[param] = results_df.groupby(param)['sharpe'].agg(['mean', 'std', 'min', 'max'])

    return param_results

# 使用示例
# sensitivity = AnalyzeParameterSensitivity(results_df)

12.8 完整优化示例

from AlgorithmImports import *

class OptimizableStrategy(QCAlgorithm):
    """
    可优化的双均线策略

    优化参数:
    - fastPeriod: 快线周期
    - slowPeriod: 慢线周期
    """

    # 注意:优化引擎不读取算法类中的方法,参数空间定义在项目目录下
    # optimization.json 的 "parameters" 中(见 12.2.2 节)。下面的辅助函数
    # 仅供本地分析时读取该配置:

    @staticmethod
    def LoadOptimizationParameters(path="optimization.json"):
        """
        读取 optimization.json 中的参数定义(辅助函数,非引擎回调)
        """
        import json
        with open(path) as f:
            return json.load(f)["parameters"]

    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

        self.spy = self.AddEquity("SPY", Resolution.Daily).Symbol

        # 获取参数(GetParameter 返回 str,需转换为数值)
        self.fast_period = int(self.GetParameter("fastPeriod") or 20)
        self.slow_period = int(self.GetParameter("slowPeriod") or 50)

        # 参数验证
        if self.fast_period >= self.slow_period:
            self.Quit(f"Invalid: fast ({self.fast_period}) >= slow ({self.slow_period})")

        # 创建指标
        self.sma_fast = self.SMA(self.spy, self.fast_period)
        self.sma_slow = self.SMA(self.spy, self.slow_period)

        self.SetWarmUp(TimeSpan.FromDays(self.slow_period + 10))

        # 输出参数
        self.Debug(f"Fast MA: {self.fast_period}, Slow MA: {self.slow_period}")

    def OnData(self, data):
        if not self.sma_fast.IsReady:
            return

        if self.sma_fast.Current.Value > self.sma_slow.Current.Value:
            if not self.Portfolio[self.spy].IsLong:
                self.SetHoldings(self.spy, 1)
        else:
            if self.Portfolio[self.spy].IsLong:
                self.Liquidate(self.spy)

    def OnEndOfAlgorithm(self):
        """输出结果用于优化评估"""
        stats = self.Statistics.TotalPerformance.PortfolioStatistics

        # 输出关键指标供优化器使用
        self.Debug(f"Return: {stats.CompoundingAnnualReturn:.2%}")
        self.Debug(f"Sharpe: {stats.SharpeRatio:.2f}")
        self.Debug(f"Drawdown: {stats.Drawdown:.2%}")
        self.Debug(f"Trades: {self.Statistics.Summary['Total Orders']}")

12.9 优化最佳实践

  1. 样本分离:使用样本内优化,样本外验证
  2. 参数约束:限制参数范围避免极端值
  3. 简化模型:简单模型更不容易过拟合
  4. 目标选择:选择稳健的优化目标
  5. 结果验证:在样本外数据上验证优化结果
  6. 敏感性分析:分析参数变化对结果的影响
  7. 避免过度优化:不要追求完美的历史表现