第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 优化最佳实践¶
- 样本分离:使用样本内优化,样本外验证
- 参数约束:限制参数范围避免极端值
- 简化模型:简单模型更不容易过拟合
- 目标选择:选择稳健的优化目标
- 结果验证:在样本外数据上验证优化结果
- 敏感性分析:分析参数变化对结果的影响
- 避免过度优化:不要追求完美的历史表现