订单流不平衡策略：捕捉高频交易中的微观结构阿尔法

def calculate_ofi(order_book_snapshots, events):
    """
    计算订单流不平衡
    
    Parameters:
    -----------
    order_book_snapshots : DataFrame
        LOB快照数据，包含买卖五档的价量信息
    events : DataFrame
        订单事件数据，包含新增、取消、成交事件
    
    Returns:
    --------
    ofi_series : DataFrame
        每个时间窗口的OFI值
    """
    ofi_buy = 0
    ofi_sell = 0
    
    for event in events:
        if event['type'] == 'add':
            if event['side'] == 'bid':
                ofi_buy += event['size']
            else:
                ofi_sell += event['size']
        elif event['type'] == 'cancel':
            if event['side'] == 'bid':
                ofi_buy -= event['size']
            else:
                ofi_sell -= event['size']
        elif event['type'] == 'trade':
            if event['aggressor'] == 'buy':
                ofi_buy += event['size']
            else:
                ofi_sell += event['size']
    
    ofi = ofi_buy - ofi_sell
    return ofi

def cross_asset_ofi(main_asset_ofi, related_assets_ofi, weights=None):
    """
    计算跨资产OFI
    
    Parameters:
    -----------
    main_asset_ofi : Series
        主资产的OFI序列
    related_assets_ofi : DataFrame
        相关资产的OFI矩阵
    weights : array-like
        各相关资产的权重
    
    Returns:
    --------
    cross_ofi : Series
        跨资产OFI序列
    """
    if weights is None:
        weights = np.ones(related_assets_ofi.shape[1]) / related_assets_ofi.shape[1]
    
    # 标准化各资产的OFI
    normalized_ofi = (related_assets_ofi - related_assets_ofi.mean()) / related_assets_ofi.std()
    
    # 计算加权OFI
    cross_ofi = normalized_ofi.dot(weights)
    
    # 与主资产OFI结合
    combined_ofi = 0.6 * main_asset_ofi + 0.4 * cross_ofi
    
    return combined_ofi

def ofi_volatility_forecast(ofi, window=20):
    """
    基于OFI的波动率预测
    
    Parameters:
    -----------
    ofi : Series
        订单流不平衡序列
    window : int
        滚动窗口
    
    Returns:
    --------
    vol_forecast : Series
        波动率预测值
    """
    # OFI的绝对值反映订单流压力强度
    ofi_abs = np.abs(ofi)
    
    # 计算OFI压力的滚动统计量
    ofi_ma = ofi_abs.rolling(window).mean()
    ofi_std = ofi_abs.rolling(window).std()
    
    # 波动率预测模型：OFI压力 + 历史波动率
    historical_vol = ofi.rolling(window).std() * np.sqrt(252 * 390)  # 年化
    
    vol_forecast = 0.3 * ofi_ma + 0.7 * historical_vol
    
    return vol_forecast

from sklearn.ensemble import RandomForestClassifier
import numpy as np

def ml_enhanced_ofi_strategy(ofi, features, lookahead=5):
    """
    机器学习增强的OFI策略
    
    Parameters:
    -----------
    ofi : Series
        OFI序列
    features : DataFrame
        特征矩阵（可包括波动率、成交量、市场情绪等）
    lookahead : int
        预测前瞻期（分钟）
    
    Returns:
    --------
    signals : Series
        交易信号（1:买入, -1:卖出, 0:无操作）
    """
    # 构建训练标签：未来lookahead分钟的价格变动方向
    future_return = ofi.shift(-lookahead) / ofi.shift(-lookahead).abs()
    labels = (future_return > 0).astype(int)
    
    # 特征工程
    X = pd.DataFrame({
        'ofi': ofi,
        'ofi_ma5': ofi.rolling(5).mean(),
        'ofi_ma20': ofi.rolling(20).mean(),
        'ofi_std20': ofi.rolling(20).std(),
    })
    X = pd.concat([X, features], axis=1).dropna()
    
    # 训练随机森林模型
    rf = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
    rf.fit(X[:-lookahead], labels[:-lookahead])
    
    # 生成信号
    probabilities = rf.predict_proba(X[-lookahead:])[:, 1]
    signals = np.where(probabilities > 0.6, 1, 
                     np.where(probabilities < 0.4, -1, 0))
    
    return signals

def market_regime_detection(price, volatility, ofi):
    """
    市场状态识别
    
    Returns:
    --------
    regime : str
        'trending', 'mean_reverting', 'high_vol', 'low_vol'
    """
    # 计算ADF检验p值（均值回归vs趋势）
    adf_pvalue = adfuller(price)[1]
    
    # 计算波动率分位数
    vol_percentile = volatility.rolling(60).apply(lambda x: pd.Series(x).rank(pct=True).iloc[-1])
    
    if vol_percentile > 0.8:
        return 'high_vol'
    elif vol_percentile < 0.2:
        return 'low_vol'
    elif adf_pvalue < 0.05:
        return 'mean_reverting'
    else:
        return 'trending'