跳转至

第13章 实盘交易准备

本章介绍实盘交易前的准备工作,包括券商接入、账户配置和风险管理。

13.1 实盘交易概述

13.1.1 回测与实盘的差异

方面 回测 实盘
数据 历史数据,确定 实时数据,不确定
滑点 模型估计 真实滑点
成交 假设能成交 可能无法成交
延迟 无延迟 网络延迟
心理 无情绪影响 心理影响决策
成本 手续费简化 实际手续费
时间 几秒完成 实时进行

13.1.2 实盘前检查清单

  • [ ] 策略经过充分回测
  • [ ] 参数经过样本外验证
  • [ ] 了解券商API和限制
  • [ ] 设置风险管理规则
  • [ ] 准备监控方案
  • [ ] 设置告警通知
  • [ ] 测试模拟盘交易

13.2 券商接入

13.2.1 支持的券商

股票/ETF券商: - Interactive Brokers - 国际券商,支持全球市场 - Tradier - 美国股票期权 - Alpaca / TradeStation / Charles Schwab / Tastytrade 等

加密货币交易所: - Coinbase(GDAX 为其旧名,Market.GDAX 已标记废弃) - Bitfinex - Binance - Kraken - Bybit

外汇券商: - OANDA - FXCM

此外还支持 Trading Technologies、Zerodha、Samco、Exante 等券商;完整清单见引擎 Launcher/config.json 的 environments 配置块。

13.2.2 Interactive Brokers 配置

安装 IB Gateway

  1. 下载 IB Gateway 或 TWS
  2. 启用 ActiveX/Socket 客户端
  3. 配置 API 端口(对应 config.json 的 ib-port,默认 4002)
  4. 创建交易账户

配置文件

{
  "live-mode": true,
  "live-mode-brokerage": "InteractiveBrokersBrokerage",

  // IB 账户信息使用扁平键(见 Launcher/config.json)
  "ib-account": "DU1234567",
  "ib-host": "127.0.0.1",
  "ib-port": "4002",
  "ib-password": "your_password",

  // 任务队列处理器为类名字符串
  "job-queue-handler": "QuantConnect.Queues.JobQueue"
}

13.2.3 加密货币交易所配置

Bitfinex 配置

{
  "live-mode": true,
  "live-mode-brokerage": "BitfinexBrokerage",

  "bitfinex-api-key": "your_api_key",
  "bitfinex-api-secret": "your_api_secret",

  "job-queue-handler": "QuantConnect.Queues.JobQueue"
}

Binance 配置

{
  "live-mode": true,
  "live-mode-brokerage": "BinanceBrokerage",

  "binance-api-key": "your_api_key",
  "binance-api-secret": "your_api_secret"
}

13.2.4 模拟盘配置

使用 Paper Brokerage 进行模拟交易:

{
  "live-mode": true,
  "live-mode-brokerage": "PaperBrokerage"
}

13.3 实盘风险管理

13.3.1 基本风险规则

class RiskManagedLiveStrategy(QCAlgorithm):
    """
    带风险管理的实盘策略
    """

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

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

        # 风险参数
        self.max_position_size = 0.2      # 单个仓位最大20%
        self.max_total_exposure = 0.8     # 总持仓最大80%
        self.max_daily_loss = 0.02        # 日最大亏损2%
        self.max_drawdown = 0.10          # 最大回撤10%

        self.daily_start_value = None
        self.peak_value = None

        # 调度:每日检查风险
        self.Schedule.On(
            self.DateRules.EveryDay(),
            self.TimeRules.BeforeMarketOpen(self.spy, 5),
            self.DailyRiskCheck
        )

    def DailyRiskCheck(self):
        """每日风险检查"""
        # 重置每日起始值
        self.daily_start_value = self.Portfolio.TotalPortfolioValue

    def CheckRiskLimits(self):
        """检查风险限制"""
        current_value = self.Portfolio.TotalPortfolioValue

        # 更新峰值
        if self.peak_value is None or current_value > self.peak_value:
            self.peak_value = current_value

        # 检查每日亏损
        if self.daily_start_value:
            daily_pnl = (current_value / self.daily_start_value - 1)

            if daily_pnl < -self.max_daily_loss:
                self.Error(f"Daily loss limit exceeded: {daily_pnl:.2%}")
                self.Liquidate()
                return False

        # 检查最大回撤
        if self.peak_value:
            drawdown = (current_value / self.peak_value - 1)

            if drawdown < -self.max_drawdown:
                self.Error(f"Max drawdown exceeded: {drawdown:.2%}")
                self.Liquidate()
                return False

        return True

    def OnData(self, data):
        # 在每次交易前检查风险
        if not self.CheckRiskLimits():
            return

        # 正常交易逻辑
        # ...

13.3.2 仓位管理

def CalculatePositionSize(self, symbol, risk_per_trade=0.02):
    """
    计算基于风险的仓位大小

    Args:
        symbol: 证券Symbol
        risk_per_trade: 每笔交易风险比例
    """
    # 获取账户总值
    portfolio_value = self.Portfolio.TotalPortfolioValue

    # 计算风险金额
    risk_amount = portfolio_value * risk_per_trade

    # 获取当前价格和ATR
    price = self.Securities[symbol].Price
    atr = self.ATR(symbol, 14).Current.Value if self.ATR(symbol, 14).IsReady else price * 0.02

    # 基于ATR的止损距离
    stop_distance = atr * 2

    # 计算股数
    if stop_distance > 0:
        shares = int(risk_amount / stop_distance)
    else:
        shares = 0

    # 检查最大仓位限制
    position_value = shares * price
    max_position_value = portfolio_value * self.max_position_size

    if position_value > max_position_value:
        shares = int(max_position_value / price)

    return shares

13.4 实盘前测试

13.4.1 模拟盘测试

class PaperTradingTest(QCAlgorithm):
    """
    模拟盘测试策略

    在实盘前,先用模拟盘测试策略
    """

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

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

        # 模拟盘模式标识
        self.is_paper_trading = True

    def OnData(self, data):
        if self.is_paper_trading:
            # 模拟盘模式:记录但不实际交易
            self.Debug(f"[PAPER] Signal at {self.Time}")
            return

        # 实盘模式
        self.ExecuteTrade()

13.4.2 实盘前验证

# 1. 连接测试(模拟盘使用 Paper Trading 券商)
lean live deploy "MyStrategy" --brokerage "Paper Trading"

# 2. 检查订单
# 观察订单是否正常生成和执行

# 3. 检查持仓
# 确认持仓正确记录

# 4. 检查收益
# 确认收益计算正确

# 5. 测试异常情况
# 断开连接、重启等

13.5 监控和告警

13.5.1 设置监控

class MonitoredLiveStrategy(QCAlgorithm):
    """
    带监控的实盘策略
    """

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

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

        # 监控变量
        self.last_log_time = self.Time
        self.log_interval = timedelta(hours=1)

        # 告警阈值
        self.alert_low_balance = 10000  # 低于1万美元告警
        self.alert_large_loss = 0.05     # 单笔亏损超过5%告警

    def LogStatus(self):
        """记录当前状态"""
        now = self.Time

        if (now - self.last_log_time) >= self.log_interval:
            portfolio = self.Portfolio

            self.Debug(f"[STATUS] {now}")
            self.Debug(f"  Portfolio Value: ${portfolio.TotalPortfolioValue:,.2f}")
            self.Debug(f"  Cash: ${portfolio.Cash:,.2f}")
            self.Debug(f"  Invested: {portfolio.Invested}")

            # 检查低余额告警
            if portfolio.Cash < self.alert_low_balance:
                self.Log(f"Low balance alert: ${portfolio.Cash:,.2f}")

            self.last_log_time = now

    def OnOrderEvent(self, orderEvent):
        """订单事件监控"""
        if orderEvent.Status == OrderStatus.Filled:
            fill_price = orderEvent.FillPrice

            # 检查大额亏损(OrderEvent 直接提供 Direction/Symbol 等成员)
            if orderEvent.Direction == OrderDirection.Sell:
                holdings = self.Portfolio[orderEvent.Symbol]
                if holdings.AveragePrice > 0:
                    pnl_pct = (fill_price / holdings.AveragePrice - 1)

                    if pnl_pct < -self.alert_large_loss:
                        self.Error(f"Large loss alert: {orderEvent.Symbol} | P&L: {pnl_pct:.2%}")

    def OnData(self, data):
        # 记录状态
        self.LogStatus()

        # 正常交易逻辑
        # ...

13.5.2 通知设置

class NotificationStrategy(QCAlgorithm):
    """
    带通知的策略
    """

    def Initialize(self):
        # ...

        # Notify 是 NotificationManager 实例,直接调用 Email/Sms/Web 方法发送,
        # 没有 NotificationType 配置结构;这里只保存通知地址
        self.alert_email = "your_email@example.com"
        self.alert_webhook_url = "https://your-webhook-url.com/alert"

    def SendAlert(self, message, level="info"):
        """
        发送告警

        Args:
            message: 告警消息
            level: 告警级别 (info, warning, error)
        """
        # 记录日志(QCAlgorithm 没有 Warn 方法,警告语义用 Log)
        if level == "error":
            self.Error(f"[ALERT] {message}")
        else:
            self.Log(f"[ALERT] {message}")

        # 发送邮件通知(地址, 主题, 内容)
        self.Notify.Email(self.alert_email, "Strategy Alert", message)

        # 发送 webhook(地址, 数据)
        payload = {"message": message, "level": level}
        self.Notify.Web(self.alert_webhook_url, payload)

13.6 实盘前最终检查

13.6.1 技术检查

  • [ ] 券商API连接正常
  • [ ] 数据源可用
  • [ ] 网络连接稳定
  • [ ] 服务器时间同步
  • [ ] 硬盘空间充足

13.6.2 策略检查

  • [ ] 策略参数确认
  • [ ] 风险参数设定
  • [ ] 止损止盈设置
  • [ ] 最大持仓限制

13.6.3 资金检查

  • [ ] 最小资金要求
  • [ ] 预留缓冲资金
  • [ ] 手续费预算
  • [ ] 保证金充足

13.7 完整示例:实盘准备策略

from AlgorithmImports import *

class LiveReadyStrategy(QCAlgorithm):
    """
    实盘准备就绪的策略

    包含完整的风险管理和监控
    """

    def Initialize(self):
        # 基本设置
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)

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

        # 添加证券
        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_size = 0.2      # 最大单仓位20%
        self.stop_loss_pct = 0.03        # 3% 止损
        self.take_profit_pct = 0.06      # 6% 止盈
        self.max_daily_loss = 0.02        # 日最大亏损2%
        self.max_drawdown = 0.10         # 最大回撤10%

        # 状态变量
        self.entry_price = None
        self.daily_start_value = None
        self.peak_value = None
        self.last_log_time = None

        # 调度任务
        self.Schedule.On(
            self.DateRules.EveryDay(self.spy),
            self.TimeRules.BeforeMarketOpen(self.spy, 5),
            self.DailyInitialize
        )

        self.Schedule.On(
            self.DateRules.EveryDay(self.spy),
            self.TimeRules.Every(TimeSpan.FromHours(1)),
            self.HourlyStatus
        )

        self.Debug("Live Ready Strategy Initialized")
        self.Debug(f"Risk Parameters: MaxPos={self.max_position_size}, "
                  f"StopLoss={self.stop_loss_pct}, TakeProfit={self.take_profit_pct}")

    def DailyInitialize(self):
        """每日初始化"""
        self.daily_start_value = self.Portfolio.TotalPortfolioValue
        self.Debug(f"\n=== Trading Day: {self.Time.date()} ===")
        self.Debug(f"Starting Value: ${self.daily_start_value:,.2f}")

    def HourlyStatus(self):
        """每小时状态检查"""
        if not self.CheckRiskLimits():
            return

        portfolio = self.Portfolio
        self.Debug(f"[{self.Time.strftime('%H:%M')}] Portfolio: ${portfolio.TotalPortfolioValue:,.2f}, "
                  f"Cash: ${portfolio.Cash:,.2f}")

    def CheckRiskLimits(self):
        """检查风险限制"""
        current_value = self.Portfolio.TotalPortfolioValue

        # 更新峰值
        if self.peak_value is None or current_value > self.peak_value:
            self.peak_value = current_value

        # 检查每日亏损
        if self.daily_start_value:
            daily_pnl = (current_value / self.daily_start_value - 1)
            if daily_pnl < -self.max_daily_loss:
                self.Error(f"Daily loss limit: {daily_pnl:.2%}. Liquidating.")
                self.Liquidate()
                return False

        # 检查最大回撤
        if self.peak_value:
            drawdown = (current_value / self.peak_value - 1)
            if drawdown < -self.max_drawdown:
                self.Error(f"Max drawdown: {drawdown:.2%}. Liquidating.")
                self.Liquidate()
                return False

        return True

    def OnData(self, data):
        # 风险检查
        if not self.CheckRiskLimits():
            return

        # 检查止损止盈
        if self.Portfolio[self.spy].Invested:
            if self.CheckExitSignals(data[self.spy].Price):
                return

        # 交易逻辑
        if self.sma_fast.IsReady and self.atr.IsReady:
            if self.sma_fast.Current.Value > self.sma_slow.Current.Value:
                if not self.Portfolio[self.spy].IsLong:
                    self.EnterPosition()
            else:
                if self.Portfolio[self.spy].IsLong:
                    self.ExitPosition("Signal Change")

    def EnterPosition(self):
        """开仓"""
        price = self.Securities[self.spy].Price

        # 计算仓位大小(基于风险)
        atr = self.atr.Current.Value
        risk_amount = self.Portfolio.TotalPortfolioValue * 0.02  # 2% 风险
        stop_distance = atr * 2

        if stop_distance > 0:
            shares = int(risk_amount / stop_distance)
        else:
            shares = int((self.Portfolio.Cash * 0.9) / price)

        # 限制最大仓位
        max_shares = int((self.Portfolio.TotalPortfolioValue * self.max_position_size) / price)
        shares = min(shares, max_shares)

        if shares > 0:
            self.MarketOrder(self.spy, shares)
            self.entry_price = price
            self.Debug(f"[ENTER] Bought {shares} shares at ${price:.2f}")

    def CheckExitSignals(self, price):
        """检查退出信号"""
        if self.entry_price is None:
            return False

        # 止损
        pnl = (price / self.entry_price - 1)

        if pnl <= -self.stop_loss_pct:
            self.ExitPosition("Stop Loss")
            return True

        # 止盈
        elif pnl >= self.take_profit_pct:
            self.ExitPosition("Take Profit")
            return True

        return False

    def ExitPosition(self, reason=""):
        """平仓"""
        if self.Portfolio[self.spy].Invested:
            price = self.Securities[self.spy].Price
            pnl = (price / self.entry_price - 1) * 100 if self.entry_price else 0

            self.Liquidate(self.spy)
            self.Debug(f"[EXIT] {reason} at ${price:.2f}, P&L: {pnl:.2f}")
            self.entry_price = None

    def OnOrderEvent(self, orderEvent):
        """订单事件"""
        if orderEvent.Status == OrderStatus.Filled:
            self.Debug(f"[ORDER] {orderEvent.Symbol} | "
                      f"Qty: {orderEvent.FillQuantity} | "
                      f"Price: ${orderEvent.FillPrice:.2f}")

    def OnEndOfAlgorithm(self):
        """结束时总结"""
        self.Debug("\n" + "="*60)
        self.Debug("LIVE READY STRATEGY - SUMMARY")
        self.Debug("="*60)
        final_return = self.Portfolio.TotalPortfolioValue / self.starting_cash - 1
        self.Debug(f"Final Return: {final_return:.2%}")
        self.Debug("="*60)