跳转至

第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}")