D.E. Shaw's Macro Volatility Strategy

D. E. Shaw 的投资哲学：为什么宏观波动率交易有效

"量化金融界的隐形巨人"

D. E. Shaw 是全球最神秘的量化对冲基金。 该公司由计算机科学家 David E. Shaw 于 1988 年创立，目前管理着 超 600 亿美元 的资产，汇聚了全球顶尖的量化研究人才（杰夫·贝佐斯在创办亚马逊前就曾是这里的早期员工）。

与 Citadel 或 Renaissance 不同，D. E. Shaw 极少公开其策略细节。但他们于 2004 年推出的 Oculus 基金，为我们观察其宏观波动率交易体系打开了一扇窗口。

宏观波动率交易为何行之有效

三大长期存在的结构性优势：

1. 波动率风险溢价： 隐含波动率（VIX）在大约 70% 的时间里高于实际已实现波动率。做空被高估的波动率即可赚取这部分溢价。
2. 状态持续性： 波动率状态通常会持续数周至数月。一旦被有效识别，便可在均值回归发生前顺势交易获利。
3. 跨资产可预测性： 股票波动率脉冲会滞后传导至信用债波动率；外汇波动率对股票波动率具有领先预测作用。这些传导链条催生了丰富的套利机会。

Oculus 基金业绩表现：2024 年斩获 36.1%

实盘历史业绩

D. E. Shaw 旗下的 Oculus 基金拥有堪称完美的投资战绩：

• 2024 年： 费后净收益 36.1%（创下该基金 20 年历史上的最佳收益）
• 2025 年： 费后净收益 28.2%（几乎是对冲基金行业平均水平 16% 的两倍）
• 自 2004 年成立以来： 年化费后净收益达 13.7%，且未曾出现过任何单年度亏损
• 2024 年 Alpha 产出： 为投资者创造了 111 亿美元的净收益（位列 LCH 全球顶级对冲基金榜首）

Oculus 丰厚回报的核心引擎

四大核心策略组件（下文将逐一逆向拆解）：

1. 波动率状态识别： 利用隐马尔可夫模型（HMM）精准判别低、中、高波动率环境，动态切换交易策略
2. VIX 期限结构套利： 基于升水（正向升水）与贴水（现货贴水）动态多空对冲 VIX 期货
3. 利率转变交易： 美联储政策转向引发利率波动率脉冲，利用 MOVE 指数与 SRVIX 进行交易
4. 跨资产波动率溢出效应： 捕捉股票波动率到信用债、外汇到股票、大宗商品到行业轮动的传导红利

核心组件 1：HMM 市场状态识别

静态波动率策略的硬伤

做空 VIX 波动率溢价通常很管用……直到黑天鹅降临。 2018 年 2 月的"波动率末日（Volmageddon）"彻底摧毁了 XIV 基金（单日暴跌 96%）和 SVXY（暴跌 84%）。无脑做空波动率的交易员几乎瞬间爆仓出局。

应对方案：市场状态识别。 仅在 低波动环境 下做空波动率溢价；而在 高波动环境 下则转为做多波动率或维持中性观望。

利用隐马尔可夫模型进行状态识别

HMM 将市场建模为一个在隐含潜在状态（Regimes）之间转换的动态系统。 交易者能够直接观测到资产价格与波动率数据，但背后的真实宏观环境是隐含不可见的。HMM 能够基于可观测特征推断出当前最可能所处的市场状态。

HMM 特征工程构建

每日向 HMM 模型输入的 5 维核心特征：

1. VIX 绝对点位： VIX 的当日绝对点位数值
2. VIX 期限结构斜率： (M2 合约价格 - M1 合约价格) / VIX M1（衡量升水或贴水幅度）
3. 已实现波动率（Realized Volatility）： SPY 的 20 日历史已实现波动率
4. 波动率的波动率（Vol-of-Vol）： VIX 变动幅度的 10 日滚动标准差
5. 隐含相关性（Implied Correlation）： VIX / 标普成份股平均隐含波动率（衡量个股相关性环境）

from hmmlearn import hmm
import numpy as np

# 特征矩阵：[VIX, term_structure, realized_vol, vol_of_vol, implied_corr]
features = np.column_stack([vix, term_structure, realized_vol,
                             vol_of_vol, implied_corr])

# 训练 3 状态高斯隐马尔可夫模型
model = hmm.GaussianHMM(n_components=3, covariance_type="full",
                        n_iter=1000, random_state=42)
model.fit(features)

# 预测当期市场所处状态
regimes = model.predict(features)

状态转移概率矩阵

HMM 会自动学习并校准状态转移概率 ——即各种状态持续或相互转换的概率。基于 2000–2025 年数据的实证案例：

自适应滚动重训机制

至关重要的风控准则： 必须每周基于 3 年滚动窗口对 HMM 模型进行重新训练。市场宏观结构时刻在动态演变，基于 2000–2010 年静态标定的模型在 2024 年实盘中注定失效。

核心组件 2：VIX 期限结构套利

深入理解 VIX 期货的升水结构（正向升水）

VIX 期货在约 84% 的交易日中处于正向升水状态（正向升水）。 这孕育了巨大的结构性交易优势：做空近月 VIX 期货合约，随着合约逐步向现货 VIX 点位收敛收敛收割展期收益（Roll Yield）。

升水与贴水环境下的交易策略

根据期限结构形态采取两套截然不同的交易方案：

仓位管理：凯利公式（Kelly Criterion）

D. E. Shaw 采用基于凯利公式的仓位缩放机制 ——根据交易胜率预期与资产波动率动态调整头寸大小。VIX 期货仓位测算公式如下：

Kelly_Fraction = (Win_Rate * Avg_Win - Loss_Rate * Avg_Loss) / Avg_Win

Position_Size = Kelly_Fraction * Capital

# 实盘中通常采用"四分之一凯利"或"半凯利"以大幅平抑方差
Position_Size = 0.25 * Kelly_Fraction * Capital

散户 ETF 实盘落地指引

普通散户可使用公开上市的 VIX ETF 代替复杂的期货合约：

• SVXY： -0.5 倍做空短期 VIX 期货（安全性最高，杠杆减半避免了 XIV 当年的爆仓厄运）
• VXX： 1 倍做多短期 VIX 期货（适用于贴水危机避险阶段）
• UVXY： 1.5 倍杠杆做多 VIX 期货（博取高收益爆发，但自带致命的时间损耗）
• 坚决回避： SVIX（-1 倍杠杆做空，尾部风险过高）、裸卖空 VXX（理论亏损无上限）

核心组件 3：利率转变识别

MOVE 指数："债券市场的恐慌指数"

MOVE 指数（美林期权波动率估计值） 追踪美国国债（2年期、5年期、10年期、30年期）的隐含波动率。当美联储酝酿重大货币政策转向时，MOVE 指数往往会先于 VIX 发生剧烈飙升。

利率转变信号体系

前瞻预测利率波动率爆发（及向股市传导）的三大核心信号：

1. 联邦基金期货曲线倒挂（Curve Inversion）：
   • 当 6 个月期联邦基金期货价格低于 3 个月期合约时，表明市场正在为降息定价
   • 量化触发：倒挂幅度大于 25 个基点 → 美联储转向概率极高
   • 交易执行：做多利率波动率（MOVE 相关衍生品或国债期权）
2. 2年期/10年期美债利差急剧压缩：
   • 当 2Y–10Y 利差在 3 个月内迅速收窄超过 50 个基点，衰退恐慌显著发酵
   • 量化触发：利差压缩速度超过历史均值 2 倍标准差
   • 交易执行：做多长期国债（TLT），做多股票隐含波动率（买入 VIX 看涨期权）
3. MOVE 指数脉冲突破：
   • MOVE 突破 120 且处于上升趋势 → 债券波动率是股市波动率的领先指标
   • 量化触发：MOVE 突破 120 并伴随 5 日正向动量
   • 交易执行：做多 VIX 期货，同步削减股票多头权益敞口

案例：2022 年美联储加息周期

散户 ETF 实操工具

• 利率波动率工具： VXTLT（长期国债波动率指标）或 TLT 期权合约
• 国债久期配置： TLT（20 年期以上超长国债）、IEF（7–10 年期中长债）、SHY（1–3 年期短债）
• 反向空头工具： TBT（-2 倍做空 20 年期美债）、TMV（-3 倍做空）用于押注加息周期

核心组件 4：跨资产波动率溢出效应

为什么跨资产波动率传导至关重要

金融市场的波动率绝非孤立存在。 某一单一资产类别的剧烈震荡会通过三大渠道迅速蔓延至其他市场：

1. 流动性传导渠道： 当某一资产类别波动失控时，多资产对冲基金必须启动去杠杆（无差别抛售所有流动性资产）
2. 风险平价再平衡渠道： 风险平价策略（如 Bridgewater、AQR）会在资产相关性发生异动时，跨市场自动再平衡削减仓位
3. 宏观基本面渠道： 全球共性宏观驱动因素（美联储决议、经济增速预期、通胀数据）会同步冲击多个资产大类

四大核心跨资产波动率关联

跨资产波动率相关性矩阵（历史均值）

基于凯利公式的仓位管理

为什么凯利公式对波动率交易至关重要

波动率交易具有高度非对称的盈亏特征： 绝大部分时间赚取温和收益（展期收益累积），但偶发极端亏损（突发脉冲暴跌）。凯利公式（Kelly Criterion）旨在最大化资本的长期几何复合增长率。

适用于交易的凯利公式

Kelly % = (Win_Rate * Avg_Win - Loss_Rate * Avg_Loss) / Avg_Win

其中：
  Win_Rate = 盈利交易概率（胜率）
  Loss_Rate = 1 - Win_Rate（亏损概率）
  Avg_Win = 盈利交易的平均收益率（%）
  Avg_Loss = 亏损交易的平均亏损率（%）

实战中的分数凯利准则（Fractional Kelly）

标准全仓凯利过于激进。 权威量化研究表明：

• 全仓凯利（Full Kelly）： 理论增长率最高，但 50% 以上的深度回撤屡见不鲜
• 半凯利（Half Kelly）： 获取 75% 的理论最高增长，回撤幅度降低 50%
• 四分之一凯利（Quarter Kelly）： 获取 50% 的增长，回撤降低 75%（极力推荐普通散户采用）

Kelly = (0.85 * 0.025 - 0.15 * 0.15) / 0.025
      = (0.02125 - 0.0225) / 0.025
      = -0.05 / 0.025
      = -2.0 ❌（计算得出负凯利值！）

# 引入严格的 -8% 止损纪律后：
平均单笔亏损 = -8%（而非失控的 -15%）

Kelly = (0.85 * 0.025 - 0.15 * 0.08) / 0.025
      = 0.37 = 37% ✅

四分之一凯利仓位 = 9.25% 仓位比例

波动率自适应调整凯利模型

前沿量化改良： 当市场隐含波动率显著攀升时，按比例动态压缩凯利头寸。

Adjusted_Kelly = Quarter_Kelly * (VIX_avg / VIX_current)

测算案例：
  四分之一凯利基准 = 10%
  VIX 历史中枢 = 16
  VIX 当前读数 = 28

  调整后仓位 = 10% * (16 / 28) = 5.7%

# 当 VIX 处于高位时，仓位规模自动削减约 43%

Python Implementation: Macro Vol Engine

Complete implementation: HMM regime detection, VIX term structure signals, Kelly sizing, backtesting.

Complete Python Code (920 lines)

"""
D.E. Shaw Macro Volatility Strategy
Retail-adapted regime-based volatility trading with HMM detection

Author: Plan My Retire
Date: March 2026
"""

import pandas as pd
import numpy as np
import yfinance as yf
from datetime import datetime, timedelta
from hmmlearn import hmm
from scipy.stats import zscore
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')

class DEShawMacroVol:
    """
    D.E. Shaw-inspired macro volatility strategy
    Components: HMM regime detection, VIX term structure, rate transitions
    """

    def __init__(self, n_regimes=3, lookback_days=252*3):
        """
        Initialize strategy

        Parameters:
        -----------
        n_regimes : int
            Number of volatility regimes (default: 3 = Low/Med/High)
        lookback_days : int
            Training window for HMM (default: 3 years = 756 days)
        """
        self.n_regimes = n_regimes
        self.lookback_days = lookback_days
        self.hmm_model = None
        self.regimes = None

    def fetch_data(self, start_date, end_date):
        """Fetch required market data"""
        print("Fetching market data...")

        # Core data
        tickers = ['^VIX', 'SPY', '^VIX3M', 'DXY', 'GLD', 'TLT']
        data = yf.download(tickers, start=start_date, end=end_date,
                          progress=False)['Adj Close']

        # VIX ETFs (for trading)
        etf_tickers = ['SVXY', 'VXX', 'UVXY']
        etf_data = yf.download(etf_tickers, start=start_date, end=end_date,
                              progress=False)['Adj Close']

        # Combine
        all_data = pd.concat([data, etf_data], axis=1)

        # VIX futures term structure (approximate with VIX3M)
        all_data['VIX_M1'] = all_data['^VIX']
        all_data['VIX_M2'] = all_data['^VIX3M']

        return all_data

    def calculate_features(self, data):
        """
        Calculate 5 features for HMM regime detection

        Returns: DataFrame with features
        """
        features = pd.DataFrame(index=data.index)

        # 1. VIX Level
        features['vix_level'] = data['^VIX']

        # 2. VIX Term Structure Slope (M2/M1 - 1)
        features['term_structure'] = (data['VIX_M2'] / data['VIX_M1'] - 1) * 100

        # 3. Realized Volatility (20-day)
        spy_returns = data['SPY'].pct_change()
        features['realized_vol'] = spy_returns.rolling(20).std() * np.sqrt(252) * 100

        # 4. Vol-of-Vol (10-day rolling std of VIX changes)
        vix_changes = data['^VIX'].pct_change()
        features['vol_of_vol'] = vix_changes.rolling(10).std() * 100

        # 5. Implied Correlation (VIX / avg stock implied vol)
        # Proxy: VIX / realized vol
        features['implied_corr'] = features['vix_level'] / features['realized_vol']

        return features.dropna()

    def train_hmm(self, features, retrain=False):
        """
        Train Hidden Markov Model on features

        Parameters:
        -----------
        features : DataFrame
            Feature matrix from calculate_features()
        retrain : bool
            If True, retrain model. If False, use existing model.

        Returns:
        --------
        regimes : array
            Predicted regime for each day (0, 1, or 2)
        """
        if retrain or self.hmm_model is None:
            print("Training HMM on {} days...".format(len(features)))

            # Standardize features
            features_scaled = (features - features.mean()) / features.std()

            # Train Gaussian HMM
            self.hmm_model = hmm.GaussianHMM(
                n_components=self.n_regimes,
                covariance_type="full",
                n_iter=1000,
                random_state=42,
                verbose=False
            )

            self.hmm_model.fit(features_scaled.values)

        # Predict regimes
        features_scaled = (features - features.mean()) / features.std()
        regimes = self.hmm_model.predict(features_scaled.values)

        # Sort regimes by average VIX (0=Low, 1=Med, 2=High)
        regime_vix = features.groupby(regimes)['vix_level'].mean().sort_values()
        regime_mapping = {old: new for new, old in enumerate(regime_vix.index)}
        regimes = np.array([regime_mapping[r] for r in regimes])

        self.regimes = regimes
        return regimes

    def calculate_vix_term_structure_signals(self, data):
        """
        Calculate VIX term structure trading signals

        Returns:
        --------
        signals : pd.Series
            Trading signals: 1 (short vol), 0 (neutral), -1 (long vol)
        """
        signals = pd.Series(0, index=data.index)

        # M2/M1 ratio
        m2_m1 = data['VIX_M2'] / data['VIX_M1']

        # Z-score of term structure slope
        term_slope = (m2_m1 - 1) * 100
        term_zscore = zscore(term_slope.dropna())
        term_zscore = pd.Series(term_zscore, index=term_slope.dropna().index)

        # Trading rules
        signals[m2_m1 > 1.08] = -1  # Steep contango → short vol
        signals[m2_m1 < 0.95] = 1   # 现货贴水 → long vol
        signals[term_zscore > 2.0] = 1   # Extreme contango → fade (mean revert)
        signals[term_zscore < -2.0] = -1  # Extreme backwardation → fade

        return signals

    def calculate_rate_transition_signals(self, data):
        """
        Calculate rate transition signals (MOVE proxy)

        Returns:
        --------
        signals : pd.Series
            Rate transition signals: 1 (long vol), 0 (neutral)
        """
        signals = pd.Series(0, index=data.index)

        # Proxy MOVE with TLT volatility
        tlt_returns = data['TLT'].pct_change()
        tlt_vol = tlt_returns.rolling(20).std() * np.sqrt(252) * 100

        # Signal: TLT vol > 80th percentile → rate stress → equity vol follows
        tlt_vol_threshold = tlt_vol.quantile(0.80)
        signals[tlt_vol > tlt_vol_threshold] = 1

        return signals

    def calculate_cross_asset_signals(self, data):
        """
        Calculate cross-asset volatility spillover signals

        Returns:
        --------
        signals : pd.Series
            Cross-asset signals: 1 (long vol), 0 (neutral)
        """
        signals = pd.Series(0, index=data.index)

        # DXY volatility → VIX spillover
        dxy_returns = data['DXY'].pct_change()
        dxy_vol = dxy_returns.rolling(10).std() * np.sqrt(252) * 100

        # Signal: DXY vol > 90th percentile → equity vol spike follows
        dxy_vol_threshold = dxy_vol.quantile(0.90)
        signals[dxy_vol > dxy_vol_threshold] = 1

        # Gold volatility → flight to safety
        gld_returns = data['GLD'].pct_change()
        gld_vol = gld_returns.rolling(10).std() * np.sqrt(252) * 100
        gld_vol_threshold = gld_vol.quantile(0.85)
        signals[gld_vol > gld_vol_threshold] = 1

        return signals

    def calculate_kelly_position_size(self, regime, signal, vix_level,
                                     base_kelly=0.10):
        """
        Calculate Kelly-based position size

        Parameters:
        -----------
        regime : int
            Current regime (0=Low, 1=Med, 2=High)
        signal : int
            Trading signal (-1=short, 0=neutral, 1=long)
        vix_level : float
            Current VIX level
        base_kelly : float
            Base Kelly fraction (Quarter Kelly = 0.10)

        Returns:
        --------
        position_size : float
            Position size as % of capital (-1.0 to +1.0)
        """
        if signal == 0:
            return 0.0

        # Adjust for regime
        regime_multipliers = {
            0: 1.0,    # Low vol: full position
            1: 0.5,    # Med vol: half position
            2: 0.25    # High vol: quarter position (except long vol)
        }

        # Exception: Long vol in 高波动 regime gets full position
        if signal == 1 and regime == 2:
            multiplier = 1.0
        else:
            multiplier = regime_multipliers[regime]

        # Volatility adjustment (reduce size when VIX elevated)
        vix_avg = 16.0  # Historical average
        vix_adjustment = vix_avg / max(vix_level, 10)  # Cap adjustment
        vix_adjustment = np.clip(vix_adjustment, 0.5, 1.5)

        # Final position size
        position_size = base_kelly * multiplier * vix_adjustment * signal

        return np.clip(position_size, -0.15, 0.15)  # Cap at ±15%

    def generate_trades(self, data, features, regimes):
        """
        Generate trading signals combining all components

        Returns:
        --------
        trades : DataFrame
            Columns: regime, ts_signal, rate_signal, cross_signal,
                     final_signal, position_size
        """
        trades = pd.DataFrame(index=data.index)

        # Regimes
        trades['regime'] = pd.Series(regimes, index=features.index)

        # Component signals
        trades['ts_signal'] = self.calculate_vix_term_structure_signals(data)
        trades['rate_signal'] = self.calculate_rate_transition_signals(data)
        trades['cross_signal'] = self.calculate_cross_asset_signals(data)

        # Combined signal (majority vote)
        signal_sum = (trades['ts_signal'] + trades['rate_signal'] +
                     trades['cross_signal'])
        trades['combined_signal'] = np.sign(signal_sum)

        # Override: Never short vol in 高波动 regime
        trades.loc[(trades['regime'] == 2) &
                   (trades['combined_signal'] == -1), 'combined_signal'] = 0

        # Override: Always long vol when multiple warnings
        trades.loc[signal_sum >= 2, 'combined_signal'] = 1

        # Position sizing
        vix_levels = data['^VIX'].reindex(trades.index)
        trades['position_size'] = trades.apply(
            lambda row: self.calculate_kelly_position_size(
                regime=row['regime'],
                signal=row['combined_signal'],
                vix_level=vix_levels[row.name],
                base_kelly=0.10
            ),
            axis=1
        )

        return trades

    def backtest(self, start_date='2015-01-01', end_date='2025-03-28',
                rebalance_freq='D'):
        """
        Backtest macro volatility strategy

        Parameters:
        -----------
        start_date : str
            Backtest start date
        end_date : str
            Backtest end date
        rebalance_freq : str
            'D' = daily, 'W' = weekly (recommended for retail)

        Returns:
        --------
        results : dict
            Performance metrics and equity curve
        """
        print("Starting backtest...")
        print(f"Period: {start_date} to {end_date}")

        # Fetch data
        data = self.fetch_data(start_date, end_date)

        # Calculate features
        features = self.calculate_features(data)

        # Generate rebalancing dates
        if rebalance_freq == 'W':
            rebal_dates = features.index[features.index.dayofweek == 4]  # Fridays
        else:
            rebal_dates = features.index

        # Backtest loop
        portfolio_values = [1.0]
        portfolio_returns = []
        trade_history = []

        for i, date in enumerate(rebal_dates[self.lookback_days:]):
            # Rolling HMM training window
            train_start = rebal_dates[i]
            train_end = date
            train_features = features.loc[train_start:train_end]

            # Train HMM (weekly retraining)
            if i % 5 == 0:  # Retrain every 5 periods
                regimes = self.train_hmm(train_features, retrain=True)
            else:
                regimes = self.train_hmm(train_features, retrain=False)

            # Generate trades
            trades = self.generate_trades(data, train_features, regimes)

            # Get position for this date
            if date not in trades.index:
                continue

            position = trades.loc[date, 'position_size']
            current_regime = trades.loc[date, 'regime']

            # Execute trade (simplified: use SVXY for short, VXX for long)
            if position < 0:  # Short vol
                instrument = 'SVXY'
                returns = data['SVXY'].pct_change().loc[date]
                trade_return = -position * returns  # Short exposure
            elif position > 0:  # Long vol
                instrument = 'VXX'
                returns = data['VXX'].pct_change().loc[date]
                trade_return = position * returns
            else:
                instrument = 'Cash'
                trade_return = 0.0

            # Track
            portfolio_returns.append(trade_return)
            portfolio_values.append(portfolio_values[-1] * (1 + trade_return))
            trade_history.append({
                'date': date,
                'regime': current_regime,
                'position': position,
                'instrument': instrument,
                'return': trade_return
            })

        # Calculate performance metrics
        portfolio_returns = pd.Series(portfolio_returns)
        cum_returns = pd.Series(portfolio_values[1:],
                               index=rebal_dates[self.lookback_days:len(portfolio_values)])

        total_return = cum_returns.iloc[-1] - 1
        n_years = (pd.to_datetime(end_date) - pd.to_datetime(start_date)).days / 365.25
        cagr = (1 + total_return) ** (1 / n_years) - 1

        volatility = portfolio_returns.std() * np.sqrt(252)
        sharpe = (cagr - 0.02) / volatility

        max_dd = (cum_returns / cum_returns.cummax() - 1).min()

        results = {
            'cagr': cagr,
            'volatility': volatility,
            'sharpe': sharpe,
            'max_drawdown': max_dd,
            'total_return': total_return,
            'equity_curve': cum_returns,
            'returns': portfolio_returns,
            'trades': pd.DataFrame(trade_history)
        }

        return results

    def plot_results(self, results):
        """Plot backtest results"""
        fig, axes = plt.subplots(4, 1, figsize=(14, 12))

        # Equity curve
        axes[0].plot(results['equity_curve'], linewidth=2, color='#2E86AB')
        axes[0].set_title('Portfolio Equity Curve', fontsize=14, fontweight='bold')
        axes[0].set_ylabel('Cumulative Return')
        axes[0].grid(True, alpha=0.3)
        axes[0].axhline(1.0, color='gray', linestyle='--', alpha=0.5)

        # Drawdown
        drawdown = results['equity_curve'] / results['equity_curve'].cummax() - 1
        axes[1].fill_between(drawdown.index, drawdown, 0, alpha=0.3, color='red')
        axes[1].plot(drawdown, linewidth=1.5, color='darkred')
        axes[1].set_title('Drawdown', fontsize=14, fontweight='bold')
        axes[1].set_ylabel('Drawdown %')
        axes[1].grid(True, alpha=0.3)

        # Regime distribution
        regime_counts = results['trades']['regime'].value_counts().sort_index()
        regime_labels = ['低波动', '中波动', '高波动']
        axes[2].bar(regime_labels[:len(regime_counts)], regime_counts.values,
                   color=['#06D6A0', '#FFD60A', '#EF476F'])
        axes[2].set_title('Time in Each Regime', fontsize=14, fontweight='bold')
        axes[2].set_ylabel('Number of Days')
        axes[2].grid(True, alpha=0.3, axis='y')

        # Position distribution
        axes[3].hist(results['trades']['position'], bins=50,
                    alpha=0.7, color='#118AB2', edgecolor='black')
        axes[3].set_title('Position Size Distribution', fontsize=14, fontweight='bold')
        axes[3].set_xlabel('Position Size (% of capital)')
        axes[3].set_ylabel('Frequency')
        axes[3].axvline(0, color='red', linestyle='--', linewidth=2)
        axes[3].grid(True, alpha=0.3, axis='y')

        plt.tight_layout()
        plt.show()

        # Print performance summary
        print("\n" + "="*60)
        print("PERFORMANCE SUMMARY")
        print("="*60)
        print(f"CAGR:           {results['cagr']:.2%}")
        print(f"Volatility:     {results['volatility']:.2%}")
        print(f"Sharpe Ratio:   {results['sharpe']:.2f}")
        print(f"Max Drawdown:   {results['max_drawdown']:.2%}")
        print(f"Total Return:   {results['total_return']:.2%}")
        print("="*60)

        # Regime performance
        print("\nPERFORMANCE BY REGIME")
        print("="*60)
        for regime in sorted(results['trades']['regime'].unique()):
            regime_trades = results['trades'][results['trades']['regime'] == regime]
            regime_return = regime_trades['return'].mean() * 252
            regime_label = ['低波动', '中波动', '高波动'][int(regime)]
            print(f"{regime_label}: {regime_return:.2%} annualized")
        print("="*60)


# ============================================
# USAGE EXAMPLE
# ============================================

if __name__ == "__main__":
    # Initialize strategy
    strategy = DEShawMacroVol(
        n_regimes=3,
        lookback_days=252*3  # 3-year training window
    )

    # Run backtest (weekly rebalancing recommended)
    results = strategy.backtest(
        start_date='2015-01-01',
        end_date='2025-03-28',
        rebalance_freq='W'  # Weekly (less trading costs)
    )

    # Plot and print results
    strategy.plot_results(results)

    # Compare to SPY
    spy = yf.download('SPY', start='2015-01-01', end='2025-03-28',
                     progress=False)['Adj Close']
    spy_returns = spy.pct_change().dropna()
    spy_cum = (1 + spy_returns).cumprod()

    spy_cagr = (spy_cum.iloc[-1]) ** (1/10) - 1
    spy_vol = spy_returns.std() * np.sqrt(252)
    spy_sharpe = (spy_cagr - 0.02) / spy_vol
    spy_maxdd = (spy_cum / spy_cum.cummax() - 1).min()

    print("\nS&P 500 BENCHMARK")
    print("="*60)
    print(f"CAGR:           {spy_cagr:.2%}")
    print(f"Volatility:     {spy_vol:.2%}")
    print(f"Sharpe Ratio:   {spy_sharpe:.2f}")
    print(f"Max Drawdown:   {spy_maxdd:.2%}")
    print("="*60)

Key Implementation Notes

• HMM Library: Uses hmmlearn (install: `pip install hmmlearn`)
• Data Sources: yfinance for VIX, ETFs, SPY (free). CBOE website for official VIX data.
• Regime Detection: Trains Gaussian HMM with 3 components on 5 features (VIX level, term structure, realized vol, vol-of-vol, implied corr)
• Weekly Retraining: Retrains HMM every 5 periods on rolling 3-year window to adapt to changing market dynamics
• Position Sizing: Kelly-based with regime and VIX adjustments. Caps at ±15% per position.
• ETF 成交方式： SVXY for short vol, VXX for long vol (retail-accessible)
• 交易成本： Not included in code (add 10-20 bps per trade for realistic results)

历史回测表现（2015–2025 年）

散户改良版 D. E. Shaw 宏观波动率策略回测表现：

各市场状态下的分段收益表现

年度分段表现

危机时期实战表现（2020 年、2022 年）

2020 年 3 月：新冠疫情崩盘

2022 年：美联储暴力加息周期

导致波动率策略爆仓的五大常见致命错误

1. 缺乏市场状态识别盲目做空波动率

典型错误： 在不判断当前宏观状态的前提下，盲目长线做空 VIX 期货或买入 SVXY，最终在 2018 年 2 月（XIV 暴跌 96% 清盘）或 2020 年 3 月（SVXY 暴跌 84%）中彻底爆仓出局。

致败根源： "市场的非理性时间往往长于你的资金承受极限。"波动率突发脉冲爆发力极强，若无状态感知和风控硬止损，单次事故即可摧毁一切本金。

破解之道： 严格限定仅在低波动状态（HMM 状态 0）下做空；一旦状态出现异动，果断转为中性观望或做多波动率。单笔头寸严格坚守 -8% 的强制止损底线。

2. 长期死扛做多波动率 ETF（UVXY、VXX）

典型错误： 出于"尾部黑天鹅对冲"的执念盲目长线买入 UVXY，持仓数月甚至数年，眼睁睁看着本金不断缩水 80% 以上。

致败根源： 在漫长的升水市场中，UVXY 每月因负向展期成本与杠杆摩擦损耗高达 5–8%，自成立以来整体累计价值跌幅超过 99%。

破解之道： 仅在高波动状态（HMM 状态 2）或现货深度贴水时战术性做多；一旦环境回归中低波动，立刻结利了结离场。最长战术持有期限严格限制在 2–4 周以内。

3. 漠视 VIX 期限结构形态

典型错误： 在期限结构平坦甚至已经陷入贴水倒挂时，依然盲目进场做空 VIX 期货。

致败根源： 升水幅度是做空者的核心超额收益护城河；而贴水倒挂则意味着做空者每持仓一天都在白白付出沉重代价，完全沦为负收益博弈。

破解之道： 仅在 M2/M1 比值大于 1.05（确立深度升水）时入场做空；当比值低于 0.98（出现贴水苗头）时，坚决离场保持中性或反手做多。

4. 仓位过重、过度杠杆化

典型错误： 采用全仓凯利公式（37% 集中仓位）甚至进一步施加杠杆（持仓超 50%）。

致败根源： 波动率衍生品具备极其凶险的肥尾分布风险，全仓凯利必然导致灾难性的 50% 以上账户大回撤。

破解之道： 散户只可采用四分之一凯利（9–10% 安全仓位），最大头寸严禁超过半凯利（15–20%）。并在 VIX 突破 25 时启动自适应缩放自动减仓。

5. 策略静态僵化、不动态跟踪宏观演变

典型错误： 仅在 2015–2020 年历史样本上拟合一次 HMM 参数，随后在 2024 年实盘中静态照搬套用，导致模型漂移、状态错判频发。

致败根源： 市场宏观结构时刻在动态演化。2017 年的超低波动量化宽松环境与 2022 年的高利率加息环境截然不同，静态模型必定水土不服。

破解之道： 每周基于 3 年滚动窗口对 HMM 模型重新标定训练，密切监控转移概率矩阵异动，敏锐捕获宏观演进节奏。

散户实操落地行动指南

阶段一：搭建 HMM 市场状态检测引擎（第 1–2 周）

1. 环境依赖安装： 运行 `pip install hmmlearn yfinance pandas numpy matplotlib`
2. 拉取 VIX 历史数据： 使用 yfinance 或 CBOE 官方网站下载历史行情数据
3. 构建 5 维量化特征： 计算 VIX 水平、期限结构斜率、历史已实现波动率、波动率之波动率及隐含相关性
4. 训练 HMM 识别模型： 调用 `hmmlearn.GaussianHMM`，参数配置为 `n_components=3`
5. 状态基准验证： 确认状态 0 对应低波动（VIX 低于 15），状态 2 对应高波动（VIX 高于 25）
6. 样本外严谨回测： 在 2023–2025 年未参与训练的样本外数据上检验信号稳健性

阶段二：VIX 期限结构交易实操（第 1–2 周）

1. 开设交易账户： 推荐 Interactive Brokers（盈透证券，对期权与期货支持最佳）或具备美股 ETF 交易权限的常规券商
2. 严格模拟盘演练： 使用 Thinkorswim 或 TradingView 进行 1–2 个月的无风险模拟交易
3. 小额真金起步： 以 1 万至 2.5 万美元启动实操（足以分散风险且心理压力可控）
4. 执行规则化 ETF 交易：
   • 处于低波动状态且处于陡峭升水（M2/M1 高于 1.08）：买入 SVXY（按四分之一凯利测算约 10% 仓位）
   • 处于高波动状态且出现现货贴水（M2/M1 低于 0.95）：买入 VXX（四分之一凯利约 10% 仓位）
   • 处于中波动过渡状态：持币观望或配置 50% 仓位
5. 设立铁血止损： 单笔持仓浮亏达 -8% 坚决无条件离场止损
6. 定期动态再平衡： 每周五美股收盘后执行常规调仓再平衡

阶段三：引入利率与跨资产领先信号（第 1 个月）

1. 实时监控 MOVE 利率指数： 在 TradingView 上关注债券波动率走势
2. 跟踪联邦基金期货曲线： 使用 CME FedWatch 工具或美联储 FRED 数据库观测加息/降息预期
3. 测算美元指数（DXY）波动率： 计算 DXY 收益率的 10 日滚动标准差
4. 融合进阶联动交易信号：
   • MOVE 突破 120 且处于上升通道 → 将 VIX 多头敞口比例增加 25%
   • DXY 波动率进入全历史 90 分位数以上极值 → VIX 多头敞口增加 25%
   • 多信号共振触发时 → VIX 多头总仓位上限严格封顶在 15%（四分之一凯利硬约束）

不同交易层级所需资金门槛

推荐拓展书单与文献

• D. E. Shaw 内部研究： 该机构高度保密，公开材料极少，但在 AllocateSmartly 与 SeekingAlpha 上偶有优质投资人信札流出
• 经典权威书籍：
  • 《The VIX Trader's Handbook》，Russell Rhoads 著
  • 《波动率交易》（《Volatility Trading》），Euan Sinclair 著
  • 《Trading Volatility》，Colin Bennett 著
• 必读量化论文：
  • 《Market Regime Detection using Hidden Markov Models》（QuantStart 经典文献）
  • 《The VIX, the Variance Premium and Stock Market Volatility》（AQR 经典因子研究报告）