第14章 实盘部署¶
本章介绍实盘交易的部署、监控和管理。
14.1 启动实盘交易¶
14.1.1 使用 Lean CLI 启动¶
# 启动实盘交易(模拟盘同样使用该命令,指定 Paper Trading 券商)
lean live deploy "MyStrategy" --brokerage "Paper Trading"
# 数据提供商、输出目录等其他选项的完整列表见:
lean live deploy --help
14.1.2 实盘配置文件¶
{
"live-mode": true,
"live-mode-brokerage": "InteractiveBrokersBrokerage",
"algorithm-type-name": "MyStrategy",
"algorithm-language": "Python",
"algorithm-location": "./MyStrategy.py",
"environments": {
"live-paper": {
"live-mode": true,
// Paper 券商(与 Launcher/config.json 的 live-paper 环境一致)
"live-mode-brokerage": "PaperBrokerage",
"setup-handler": "QuantConnect.Lean.Engine.Setup.BrokerageSetupHandler",
"data-feed-handler": "QuantConnect.Lean.Engine.DataFeeds.LiveTradingDataFeed",
"data-queue-handler": [ "QuantConnect.Lean.Engine.DataFeeds.Queues.LiveDataQueue" ],
"transaction-handler": "QuantConnect.Lean.Engine.TransactionHandlers.BacktestingTransactionHandler"
}
}
}
14.2 实盘监控¶
14.2.1 查看实时状态¶
# 查看云端实盘项目状态
lean cloud status
# 查看本地实盘项目日志(项目名为位置参数)
lean logs "MyStrategy"
14.2.2 监控指标¶
需要持续监控的指标:
| 指标 | 说明 | 正常范围 |
|---|---|---|
| 连接状态 | 与券商的连接 | Connected |
| 订单状态 | 订单执行情况 | Filled/Rejected |
| 持仓价值 | 当前持仓 | 符合预期 |
| 浮动盈亏 | 未实现盈亏 | 在止损范围内 |
| 账户余额 | 可用现金 | > 最小要求 |
| 系统延迟 | 订单执行延迟 | < 1秒 |
14.2.3 实盘监控策略¶
class LiveMonitoringStrategy(QCAlgorithm):
"""
带完整监控的实盘策略
"""
def Initialize(self):
self.SetStartDate(2023, 1, 1)
self.SetEndDate(2099, 12, 31) # 实盘使用很远的结束日期
self.SetCash(100000)
self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
# 指标
self.sma_fast = self.SMA(self.spy, 20)
self.sma_slow = self.SMA(self.spy, 50)
self.SetWarmUp(TimeSpan.FromDays(60))
# 监控变量
self.start_value = None
self.high_value = None
self.low_value = None
self.orders_today = 0
self.last_date = None
# 每日初始化
self.Schedule.On(
self.DateRules.EveryDay(self.spy),
self.TimeRules.BeforeMarketOpen(self.spy, 30),
self.DailyInit
)
# 每日收盘后报告
self.Schedule.On(
self.DateRules.EveryDay(self.spy),
self.TimeRules.AfterMarketClose(self.spy, 5),
self.DailyReport
)
def DailyInit(self):
"""每日初始化"""
self.orders_today = 0
self.last_date = self.Time.date()
current_value = self.Portfolio.TotalPortfolioValue
if self.start_value is None:
self.start_value = current_value
self.high_value = current_value
self.low_value = current_value
def OnData(self, data):
# 更新高低点
current_value = self.Portfolio.TotalPortfolioValue
if current_value > self.high_value:
self.high_value = current_value
if current_value < self.low_value:
self.low_value = current_value
# 交易逻辑
if self.sma_fast.IsReady:
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 DailyReport(self):
"""生成每日报告"""
current_value = self.Portfolio.TotalPortfolioValue
daily_return = (current_value / self.start_value - 1) if self.start_value else 0
# 计算日内高低点
intraday_range = (self.high_value / self.low_value - 1) if self.low_value > 0 else 0
self.Debug("\n" + "="*60)
self.Debug(f"DAILY REPORT - {self.Time.date()}")
self.Debug("="*60)
self.Debug(f"Starting Value: ${self.start_value:,.2f}")
self.Debug(f"Ending Value: ${current_value:,.2f}")
self.Debug(f"Daily Return: {daily_return:.2%}")
self.Debug(f"High: ${self.high_value:,.2f}")
self.Debug(f"Low: ${self.low_value:,.2f}")
self.Debug(f"Range: {intraday_range:.2%}")
self.Debug(f"Orders Today: {self.orders_today}")
self.Debug("="*60)
def OnOrderEvent(self, orderEvent):
"""记录订单"""
if orderEvent.Status == OrderStatus.Filled:
self.orders_today += 1
# 记录交易详情(OrderEvent 直接提供 Symbol/Direction 等成员)
self.Debug(f"[ORDER] {self.Time} | {orderEvent.Symbol} | "
f"{orderEvent.Direction} | "
f"Qty: {orderEvent.FillQuantity} | "
f"Price: ${orderEvent.FillPrice:.2f}")
elif orderEvent.Status == OrderStatus.Canceled:
self.Log(f"[CANCELED] {orderEvent.Symbol} | {orderEvent.OrderId}")
elif orderEvent.Status == OrderStatus.Invalid:
self.Error(f"[INVALID] {orderEvent.Symbol} | {orderEvent.Message}")
def OnEndOfAlgorithm(self):
"""结束时报告"""
self.Debug("\n" + "="*60)
self.Debug("LIVE TRADING SUMMARY")
self.Debug("="*60)
14.3 异常处理¶
14.3.1 连接异常¶
class RobustLiveStrategy(QCAlgorithm):
"""
带异常处理的实盘策略
"""
def Initialize(self):
self.SetStartDate(2023, 1, 1)
self.SetEndDate(2099, 12, 31)
self.SetCash(100000)
self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
# 连接检查
self.last_connection_check = self.Time
self.connection_issues = 0
# 每5分钟检查连接
self.Schedule.On(
self.DateRules.EveryDay(),
self.TimeRules.Every(TimeSpan.FromMinutes(5)),
self.CheckConnection
)
def CheckConnection(self):
"""检查连接状态"""
try:
# 检查数据是否更新
if self.Securities[self.spy].HasData:
# 检查数据时间
data_time = self.Securities[self.spy].LocalTime
time_diff = (self.Time - data_time).total_seconds()
if time_diff > 300: # 5分钟无数据
self.Log(f"No data for {time_diff} seconds")
self.connection_issues += 1
else:
self.connection_issues = 0
self.last_connection_check = self.Time
except Exception as e:
self.Error(f"Connection check failed: {str(e)}")
self.connection_issues += 1
# 连接问题过多时停止交易
if self.connection_issues > 3:
self.Error("Too many connection issues. Stopping trading.")
self.Liquidate()
def OnData(self, data):
# 检查数据可用性
if not data.ContainsKey(self.spy) or data[self.spy] is None:
self.Log(f"No data for {self.spy} at {self.Time}")
return
# 检查价格有效性
price = data[self.spy].Price
if price <= 0:
self.Log(f"Invalid price: {price}")
return
# 正常交易逻辑
# ...
14.3.2 订单异常处理¶
def OnOrderEvent(self, orderEvent):
"""处理订单异常"""
# 订单被拒绝
if orderEvent.Status == OrderStatus.Invalid:
self.Error(f"Order invalid: {orderEvent.Symbol} | {orderEvent.Message}")
# 常见原因:
# - 资金不足
# - 市场关闭
# - 持仓限制
# - API 限制
# 订单取消
elif orderEvent.Status == OrderStatus.Canceled:
self.Log(f"Order canceled: {orderEvent.Symbol} | ID: {orderEvent.OrderId}")
# 部分成交
elif orderEvent.Status == OrderStatus.PartiallyFilled:
remaining = orderEvent.Quantity - orderEvent.FillQuantity
self.Log(f"Partial fill: {orderEvent.Symbol} | Filled: {orderEvent.FillQuantity}, Remaining: {remaining}")
# 可以选择取消剩余部分(OrderEvent 没有 Cancel 方法,需通过 OrderTicket 取消)
# self.Transactions.GetOrderTicket(orderEvent.OrderId).Cancel()
14.4 实盘维护¶
14.4.1 定期维护任务¶
| 任务 | 频率 | 说明 |
|---|---|---|
| 检查日志 | 每天 | 查看错误和警告 |
| 审查交易 | 每天 | 确认交易符合预期 |
| 性能评估 | 每周 | 对比实际表现与预期 |
| 参数审查 | 每月 | 检查是否需要调整 |
| 系统更新 | 按需 | 更新系统和依赖 |
14.4.2 日志管理¶
class LoggingStrategy(QCAlgorithm):
"""
带日志管理的策略
"""
def Initialize(self):
self.SetStartDate(2023, 1, 1)
self.SetEndDate(2099, 12, 31)
self.SetCash(100000)
self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
self.sma_fast = self.SMA(self.spy, 20)
self.sma_slow = self.SMA(self.spy, 50)
self.SetWarmUp(TimeSpan.FromDays(60))
# 日志级别(QCAlgorithm 没有 Warn 方法,WARN 级别也使用 Log)
self.log_types = {
'DEBUG': self.Debug,
'INFO': self.Log,
'WARN': self.Log,
'ERROR': self.Error
}
def LogTrade(self, message, level="INFO"):
"""
记录交易日志
Args:
message: 日志消息
level: 日志级别
"""
log_func = self.log_types.get(level, self.Log)
# 添加时间戳和上下文
full_message = f"[{self.Time}] {message}"
log_func(full_message)
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.LogTrade(f"BUY Signal | Fast: {self.sma_fast.Current.Value:.2f} > Slow: {self.sma_slow.Current.Value:.2f}")
self.SetHoldings(self.spy, 1)
def OnOrderEvent(self, orderEvent):
"""记录订单事件"""
if orderEvent.Status in [OrderStatus.Filled, OrderStatus.Canceled, OrderStatus.Invalid]:
self.LogTrade(
f"Order {orderEvent.Status} | "
f"{orderEvent.Symbol} | "
f"Qty: {orderEvent.FillQuantity} | "
f"Price: ${orderEvent.FillPrice:.2f}",
level="INFO" if orderEvent.Status == OrderStatus.Filled else "WARN"
)
14.5 实盘停止¶
14.5.1 正常停止¶
# 停止本地实盘项目
lean live stop "MyStrategy"
# 或按 Ctrl+C
14.5.2 紧急停止¶
class EmergencyStopStrategy(QCAlgorithm):
"""
带紧急停止功能的策略
"""
def Initialize(self):
self.SetStartDate(2023, 1, 1)
self.SetEndDate(2099, 12, 31)
self.SetCash(100000)
# Portfolio 没有 StartingCash 属性,在此保存初始资金
self.starting_cash = self.Portfolio.TotalPortfolioValue
self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
# 紧急停止条件
self.emergency_stop = False
self.max_loss_pct = 0.15 # 亏损15%紧急停止
# 每30分钟检查
self.Schedule.On(
self.DateRules.EveryDay(),
self.TimeRules.Every(TimeSpan.FromMinutes(30)),
self.CheckEmergencyStop
)
def CheckEmergencyStop(self):
"""检查是否需要紧急停止"""
if self.emergency_stop:
self.Liquidate()
self.Quit("Emergency stop activated")
# 检查亏损
total_return = (self.Portfolio.TotalPortfolioValue /
self.starting_cash - 1)
if total_return < -self.max_loss_pct:
self.Error(f"Emergency stop triggered! Loss: {total_return:.2%}")
self.emergency_stop = True
self.Liquidate()
def OnData(self, data):
if self.emergency_stop:
return
# 正常交易逻辑
# ...
14.6 完整示例:生产级实盘策略¶
from AlgorithmImports import *
class ProductionLiveStrategy(QCAlgorithm):
"""
生产级实盘策略
特点:
- 完整的风险管理
- 异常处理
- 日志记录
- 监控告警
"""
def Initialize(self):
"""初始化"""
# 时间设置(实盘使用很远未来日期)
self.SetStartDate(2023, 1, 1)
self.SetEndDate(2099, 12, 31)
self.SetCash(100000)
# 添加证券
self.spy = self.AddEquity("SPY", Resolution.Minute).Symbol
self.Securities[self.spy].SetDataNormalizationMode(
DataNormalizationMode.Adjusted
)
# 指标
self.sma_fast = self.SMA(self.spy, 20)
self.sma_slow = self.SMA(self.spy, 50)
self.atr = self.ATR(self.spy, 14)
self.SetWarmUp(TimeSpan.FromDays(60))
# ========== 风险参数 ==========
self.max_position = 0.2
self.stop_loss = 0.03
self.take_profit = 0.06
self.daily_loss_limit = 0.02
self.max_drawdown = 0.10
# 状态变量
self.entry_price = None
self.entry_time = None
self.daily_start_value = None
self.peak_value = None
self.connection_issues = 0
# ========== 调度 ==========
self.Schedule.On(
self.DateRules.EveryDay(self.spy),
self.TimeRules.BeforeMarketOpen(self.spy, 30),
self.DailyInit
)
self.Schedule.On(
self.DateRules.EveryDay(self.spy),
self.TimeRules.AfterMarketClose(self.spy, 5),
self.DailyReport
)
# ========== 启动日志 ==========
self.Log("Production Live Strategy Started")
self.Log(f"Risk limits: MaxPos={self.max_position}, "
f"StopLoss={self.stop_loss}, DailyLoss={self.daily_loss_limit}")
def DailyInit(self):
"""每日初始化"""
self.daily_start_value = self.Portfolio.TotalPortfolioValue
if self.peak_value is None:
self.peak_value = self.daily_start_value
self.Log(f"=== Trading Day {self.Time.date()} ===")
self.Log(f"Starting Value: ${self.daily_start_value:,.2f}")
def DailyReport(self):
"""每日报告"""
current_value = self.Portfolio.TotalPortfolioValue
daily_return = (current_value / self.daily_start_value - 1)
self.Log(f"\n[DAILY REPORT]")
self.Log(f"Date: {self.Time.date()}")
self.Log(f"Starting: ${self.daily_start_value:,.2f}")
self.Log(f"Ending: ${current_value:,.2f}")
self.Log(f"Return: {daily_return:.2%}")
self.Log(f"Peak: ${self.peak_value:,.2f}")
def OnData(self, data):
"""主数据处理"""
# 风险检查
if not self.CheckRiskLimits():
return
# 数据检查
if not self.ValidateData(data):
return
# 检查止损止盈
if self.Portfolio[self.spy].Invested:
if self.CheckExitConditions(data[self.spy].Price):
return
# 交易逻辑
if self.sma_fast.IsReady and self.atr.IsReady:
fast = self.sma_fast.Current.Value
slow = self.sma_slow.Current.Value
if fast > slow and not self.Portfolio[self.spy].IsLong:
self.OpenPosition(data[self.spy].Price)
elif fast < slow and self.Portfolio[self.spy].IsLong:
self.ClosePosition("Signal Change")
def ValidateData(self, data):
"""验证数据有效性"""
if not data.ContainsKey(self.spy) or data[self.spy] is None:
return False
price = data[self.spy].Price
if price <= 0 or price > 1000000: # 价格合理性检查
self.Log(f"Invalid price: ${price}")
return False
return True
def CheckRiskLimits(self):
"""检查风险限制"""
current = self.Portfolio.TotalPortfolioValue
# 更新峰值
if current > self.peak_value:
self.peak_value = current
# 每日亏损限制
if self.daily_start_value:
daily_pnl = (current / self.daily_start_value - 1)
if daily_pnl < -self.daily_loss_limit:
self.Error(f"Daily loss limit: {daily_pnl:.2%}")
self.Liquidate()
return False
# 最大回撤限制
drawdown = (current / self.peak_value - 1)
if drawdown < -self.max_drawdown:
self.Error(f"Max drawdown: {drawdown:.2%}")
self.Liquidate()
return False
return True
def OpenPosition(self, price):
"""开仓"""
atr = self.atr.Current.Value
risk_amount = self.Portfolio.Cash * 0.02
shares = int(risk_amount / (atr * 2))
max_shares = int((self.Portfolio.TotalPortfolioValue * self.max_position) / price)
shares = min(shares, max_shares)
if shares > 0:
self.MarketOrder(self.spy, shares)
self.entry_price = price
self.entry_time = self.Time
self.Log(f"[BUY] {shares} shares at ${price:.2f}")
def ClosePosition(self, reason=""):
"""平仓"""
if self.Portfolio[self.spy].Invested:
price = self.Securities[self.spy].Price
self.Liquidate(self.spy)
self.Log(f"[SELL] {reason} at ${price:.2f}")
self.entry_price = None
def CheckExitConditions(self, price):
"""检查退出条件"""
if self.entry_price:
pnl = (price / self.entry_price - 1)
# 止损
if pnl <= -self.stop_loss:
self.ClosePosition(f"Stop Loss ({pnl:.2%})")
return True
# 止盈
if pnl >= self.take_profit:
self.ClosePosition(f"Take Profit ({pnl:.2%})")
return True
return False
def OnOrderEvent(self, orderEvent):
"""订单事件"""
if orderEvent.Status == OrderStatus.Filled:
self.Log(f"[ORDER FILLED] {orderEvent.Symbol} | "
f"Qty: {orderEvent.FillQuantity} | "
f"Price: ${orderEvent.FillPrice:.2f}")
elif orderEvent.Status == OrderStatus.Invalid:
self.Error(f"[ORDER INVALID] {orderEvent.Symbol} | {orderEvent.Message}")
elif orderEvent.Status == OrderStatus.Canceled:
self.Log(f"[ORDER CANCELED] {orderEvent.Symbol}")