跳转至

第8章 Algorithm Framework 框架化开发

本章介绍 Lean Framework 模块化策略开发,将策略拆分为 Alpha、Portfolio Construction、Execution、Risk 和 Universe Selection 五个模型。

8.1 Framework 概述

8.1.1 为什么使用 Framework?

传统策略将所有逻辑写在一个类中:

class TraditionalStrategy(QCAlgorithm):
    def OnData(self, data):
        # 信号生成
        # 组合构建
        # 订单执行
        # 风险控制
        # 全部混在一起...

Framework 将策略拆分为独立模块:

┌─────────────────────────────────────────────────────┐
│                  QCAlgorithm                         │
│  ┌─────────────┐  ┌──────────────┐  ┌────────────┐  │
│  │ Alpha Model │─>│ Portfolio    │─>│ Execution  │  │
│  │ (信号生成)   │  │ Construction │  │ (执行)     │  │
│  └─────────────┘  │ (组合构建)    │  └────────────┘  │
│                   └──────────────┘                   │
│  ┌─────────────┐  ┌──────────────┐                 │
│  │ Risk Model  │  │ Universe     │                 │
│  │ (风险控制)   │  │ Selection    │                 │
│  └─────────────┘  │ (证券选择)    │                 │
│                   └──────────────┘                 │
└─────────────────────────────────────────────────────┘

8.1.2 五大模型

模型 职责 输出
Alpha Model 生成交易信号 Insight 对象
Portfolio Construction 将 Insight 转为目标权重 PortfolioTarget
Execution Model 执行交易订单 OrderTicket
Risk Model 监控和管理风险 PortfolioTarget
Universe Selection 选择交易标的 Symbol 列表

8.2 Alpha Model(信号模型)

8.2.1 Insight 对象

Insight 是 Alpha Model 的输出,表示对未来价格的预测:

from AlgorithmImports import *

# 创建 Insight
insight = Insight.Price(
    symbol,                    # Symbol
    TimeSpan.FromDays(7),      # 持有期
    InsightDirection.Up        # 方向: Up/Down/Flat
)

# Insight 属性
insight.Symbol      # 证券
insight.Direction   # 方向
insight.Magnitude   # 预测强度 (0-1)
insight.CloseTimeUtc  # 过期时间 (UTC)
insight.Period      # 持有期间

8.2.2 简单 Alpha Model

class RsiAlphaModel(AlphaModel):
    """
    RSI Alpha 模型

    生成规则:
    - RSI < 30: 买入信号 (Up)
    - RSI > 70: 卖出信号 (Down)
    - 其他: 持有/观望 (Flat)
    """

    def __init__(self, period=14, overbought=70, oversold=30):
        self.period = period
        self.overbought = overbought
        self.oversold = oversold
        self.rsi_indicators = {}

    def Update(self, algorithm, data):
        """生成信号"""
        insights = []

        for symbol, rsi in self.rsi_indicators.items():
            if not rsi.IsReady:
                continue

            rsi_value = rsi.Current.Value

            # 超卖:买入信号
            if rsi_value < self.oversold:
                insights.append(Insight.Price(
                    symbol,
                    TimeSpan.FromDays(7),
                    InsightDirection.Up,
                    magnitude=(self.oversold - rsi_value) / self.oversold
                ))

            # 超买:卖出信号
            elif rsi_value > self.overbought:
                insights.append(Insight.Price(
                    symbol,
                    TimeSpan.FromDays(7),
                    InsightDirection.Down,
                    magnitude=(rsi_value - self.overbought) / (100 - self.overbought)
                ))

        return insights

    def OnSecuritiesChanged(self, algorithm, changes):
        """证券变化时创建/移除指标"""
        for added in changes.AddedSecurities:
            symbol = added.Symbol
            self.rsi_indicators[symbol] = algorithm.RSI(symbol, self.period)

        for removed in changes.RemovedSecurities:
            if removed.Symbol in self.rsi_indicators:
                del self.rsi_indicators[removed.Symbol]

8.2.3 复合 Alpha Model

class CompositeAlphaModel(AlphaModel):
    """
    复合 Alpha 模型

    结合多个信号源的 Alpha Model
    """

    def __init__(self):
        self.alpha_models = [
            RsiAlphaModel(),      # 8.2.2 中定义的自定义模型
            MacdAlphaModel()      # Lean 内置模型(Algorithm.Framework/Alphas)
        ]

    def Update(self, algorithm, data):
        """聚合所有模型的信号"""
        all_insights = []

        for alpha_model in self.alpha_models:
            insights = alpha_model.Update(algorithm, data)
            all_insights.extend(insights)

        return all_insights

    def OnSecuritiesChanged(self, algorithm, changes):
        """传递给所有子模型"""
        for alpha_model in self.alpha_models:
            alpha_model.OnSecuritiesChanged(algorithm, changes)

8.3 Portfolio Construction Model

8.3.1 基本组合构建模型

class EqualWeightingPortfolioConstructionModel(PortfolioConstructionModel):
    """
    等权重组合构建模型

    所有 Insight 获得相同的资金分配
    """

    def CreateTargets(self, algorithm, insights):
        """创建组合目标"""
        targets = []

        if not insights:
            return targets

        # 计算权重
        long_count = sum(1 for i in insights if i.Direction == InsightDirection.Up)
        short_count = sum(1 for i in insights if i.Direction == InsightDirection.Down)

        long_weight = 1.0 / long_count if long_count > 0 else 0
        short_weight = 1.0 / short_count if short_count > 0 else 0

        # 创建目标
        for insight in insights:
            if insight.Direction == InsightDirection.Up:
                targets.append(PortfolioTarget.Percent(
                    insight.Symbol,
                    long_weight * insight.Magnitude
                ))
            elif insight.Direction == InsightDirection.Down:
                targets.append(PortfolioTarget.Percent(
                    insight.Symbol,
                    -short_weight * insight.Magnitude
                ))

        return targets

8.3.2 Black-Litterman 模型

class BlackLittermanPortfolioModel(PortfolioConstructionModel):
    """
    Black-Litterman 组合模型

    结合市场均衡和投资者观点
    """

    def __init__(self, rebalance=Expiry.EndOfMonth, portfolioBias=PortfolioBias.LongShort):
        self.rebalance = rebalance
        self.portfolioBias = portfolioBias
        self.symbolData = {}

    def CreateTargets(self, algorithm, insights):
        """基于 Black-Litterman 创建目标"""
        # 这里简化实现
        # 实际需要实现完整的 BL 模型

        targets = []

        for insight in insights:
            # 根据 Insight 的 Magnitude 分配权重
            weight = insight.Magnitude / len(insights)

            if self.portfolioBias == PortfolioBias.Long:
                weight = abs(weight)

            targets.append(PortfolioTarget.Percent(
                insight.Symbol,
                weight
            ))

        return targets

8.4 Execution Model

8.4.1 立即执行模型

class ImmediateExecutionModel(ExecutionModel):
    """
    立即执行模型

    收到目标后立即下单
    """

    def Execute(self, algorithm, targets):
        """执行目标"""
        for target in targets:
            # 计算需要交易的数量
            if not algorithm.Portfolio.ContainsKey(target.Symbol):
                continue

            holdings = algorithm.Portfolio[target.Symbol]

            # 目标数量减去当前持仓,得到需要交易的数量
            # 注意:PortfolioTarget.Quantity 是目标股数;
            # CalculateOrderQuantity 的第二参是目标持仓百分比,勿混用
            quantity = target.Quantity - holdings.Quantity

            if quantity != 0:
                algorithm.MarketOrder(target.Symbol, quantity)

8.4.2 VWAP 执行模型

class VwapExecutionModel(ExecutionModel):
    """
    VWAP 执行模型

    在一段时间内分批执行,追求接近 VWAP 价格
    """

    def __init__(self, period=TimeSpan.FromMinutes(30)):
        self.period = period
        self.targets = {}
        self.executed_symbols = set()

    def Execute(self, algorithm, targets):
        """执行目标"""
        for target in targets:
            symbol = target.Symbol

            # 新目标
            if symbol not in self.targets:
                self.targets[symbol] = {
                    'target': target,
                    'remaining': target.Quantity,
                    'start_time': algorithm.Time
                }

            # 检查是否完成
            if self.targets[symbol]['remaining'] <= 0:
                continue

            # 计算本次应该执行的数量
            # (.NET TimeSpan 用 TotalSeconds 属性)
            time_elapsed = (algorithm.Time - self.targets[symbol]['start_time']).TotalSeconds
            total_period = self.period.TotalSeconds

            if time_elapsed >= total_period:
                # 时间到,立即完成剩余
                quantity = self.targets[symbol]['remaining']
            else:
                # 按时间比例执行
                quantity = int(self.targets[symbol]['target'].Quantity *
                             (time_elapsed / total_period)) - \
                         (self.targets[symbol]['target'].Quantity - self.targets[symbol]['remaining'])

            if quantity != 0:
                algorithm.MarketOrder(symbol, quantity)
                self.targets[symbol]['remaining'] -= quantity

8.5 Risk Model

8.5.1 最大回撤风险模型

class MaxDrawdownRiskManagementModel(RiskManagementModel):
    """
    最大回撤风险管理模型

    当组合回撤超过阈值时平仓
    """

    def __init__(self, max_drawdown=0.1):
        self.max_drawdown = max_drawdown
        self.high_watermark = None

    def ManageRisk(self, algorithm, targets):
        """管理风险"""
        portfolio_value = algorithm.Portfolio.TotalPortfolioValue

        # 更新最高水位
        if self.high_watermark is None or portfolio_value > self.high_watermark:
            self.high_watermark = portfolio_value
            return targets  # 正常,返回原目标

        # 计算回撤
        drawdown = (self.high_watermark - portfolio_value) / self.high_watermark

        if drawdown > self.max_drawdown:
            # 超过最大回撤,平掉所有持仓
            algorithm.Debug(f"Max drawdown exceeded: {drawdown:.2%}. Liquidating all positions.")
            algorithm.Liquidate()

            return []  # 清空所有目标

        return targets

8.5.2 单股最大持仓风险模型

class MaxPositionSizeRiskModel(RiskManagementModel):
    """
    单股最大持仓风险管理模型
    """

    def __init__(self, max_position_size=0.2):
        self.max_position_size = max_position_size

    def ManageRisk(self, algorithm, targets):
        """管理风险"""
        filtered_targets = []

        for target in targets:
            # 计算目标持仓占比
            target_value = abs(target.Quantity) * algorithm.Securities[target.Symbol].Price
            portfolio_value = algorithm.Portfolio.TotalPortfolioValue

            if portfolio_value > 0:
                position_size = target_value / portfolio_value

                if position_size > self.max_position_size:
                    # 超过限制,调整到最大值
                    adjusted_quantity = int(
                        (self.max_position_size * portfolio_value) /
                        algorithm.Securities[target.Symbol].Price
                    )

                    if target.Quantity > 0:
                        adjusted_quantity = abs(adjusted_quantity)
                    else:
                        adjusted_quantity = -abs(adjusted_quantity)

                    target = PortfolioTarget(target.Symbol, adjusted_quantity)

            filtered_targets.append(target)

        return filtered_targets

8.6 完整 Framework 策略示例

from AlgorithmImports import *

class FrameworkStrategyAlgorithm(QCAlgorithm):
    """
    完整的 Framework 策略

    使用所有五个模型构建
    """

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

        # 设置 Universe:惯用入口是 AddUniverse(粗筛 + 精筛)
        # 注意:Framework 模式下 SetUniverseSelection 只接受
        # IUniverseSelectionModel(如 ManualUniverseSelectionModel),
        # 不能传入 Universe 对象
        self.AddUniverse(self.CoarseSelection, self.FineSelection)

        # 设置 Alpha 模型
        self.SetAlpha(RsiAlphaModel(period=14, overbought=70, oversold=30))

        # 设置组合构建模型
        self.SetPortfolioConstruction(EqualWeightingPortfolioConstructionModel())

        # 设置执行模型
        self.SetExecution(ImmediateExecutionModel())

        # 设置风险管理模型
        self.SetRiskManagement(MaxDrawdownRiskManagementModel(max_drawdown=0.15))

        # 设置预热
        self.SetWarmUp(TimeSpan.FromDays(30))

    def CoarseSelection(self, coarse):
        """粗筛选"""
        filtered = [c for c in coarse if c.Price > 10 and c.Volume > 1000000]
        sorted_by_volume = sorted(filtered, key=lambda c: c.DollarVolume, reverse=True)
        return [c.Symbol for c in sorted_by_volume[:100]]

    def FineSelection(self, fine):
        """精筛选"""
        filtered = [f for f in fine if 0 < f.ValuationRatios.PERatio < 30]
        sorted_by_pe = sorted(filtered, key=lambda f: f.ValuationRatios.PERatio)
        return [f.Symbol for f in sorted_by_pe[:20]]