Skip to content

title: Chapter 12: Parameter Optimization

Chapter 12: Parameter Optimization

This chapter introduces Lean's parameter optimization features, including grid search, optimization strategies, and result analysis.

12.1 Optimization Overview

12.1.1 What Is Parameter Optimization?

Parameter optimization is the process of systematically testing different parameter combinations to find the optimal parameters.

12.1.2 Optimization Objectives

Common optimization objectives: - Sharpe Ratio: risk-adjusted return - Total Return: total return - Sortino Ratio: downside risk-adjusted return - Drawdown: controlling maximum drawdown - Win Rate: win rate - Profit-Loss Ratio: profit-loss ratio

12.2 Optimizing with the Lean CLI

12.2.1 The Optimization Configuration File

The Lean CLI has no lean optimize create subcommand. The parameter space is defined directly in an optimization.json file in the project directory (its structure derives from the engine optimizer configuration Optimizer.Launcher/config.example.json), and running lean optimize "ProjectName" reads that file.

12.2.2 optimization.json Format

{
  // 优化目标:从回测输出 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 Running an Optimization

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

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

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

12.3 Parameterized Strategies

12.3.1 Defining Strategy Parameters

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 Parameter Constraints

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 Optimization Strategies

Grid search is the most common optimization method; it exhaustively enumerates all parameter combinations:

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

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

12.4.2 Adaptive Optimization

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 Avoiding Overfitting

12.5.1 Signs of Overfitting

Sign Description
Too many parameters Number of parameters too large relative to the amount of data
Extremely high Sharpe ratio Abnormally high backtest Sharpe ratio (>5)
Few trades Strategy trades too infrequently
Complex rules Rules too complex to explain
Good in-sample performance Good in-sample but poor out-of-sample

12.5.2 Methods to Prevent Overfitting

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 Multi-Objective Optimization

12.6.1 Composite Scoring Function

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 Analyzing Optimization Results

12.7.1 Viewing Optimization Results

lean optimize has no results subcommand. After an optimization completes, the results are written directly to an optimizations/<timestamp>/ folder in the project directory, containing the result JSON and logs of the backtest for each parameter combination:

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

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

12.7.2 Parameter Sensitivity Analysis

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

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 Complete Optimization Example

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 Optimization Best Practices

  1. Sample separation: optimize in-sample, validate out-of-sample
  2. Parameter constraints: limit parameter ranges to avoid extreme values
  3. Simpler models: simple models are less prone to overfitting
  4. Objective selection: choose robust optimization objectives
  5. Result validation: validate optimization results on out-of-sample data
  6. Sensitivity analysis: analyze how parameter changes affect results
  7. Avoid over-optimization: do not chase perfect historical performance