订单簿失衡 LSTM：用深度模型预测秒级价格方向

import numpy as np
import pandas as pd

def build_lob_features(lob_df, levels=5):
    """
    lob_df: 每行一个 tick, 列包含 bid_px_1..5, bid_sz_1..5, ask_px_1..5, ask_sz_1..5
    返回特征 DataFrame
    """
    feats = pd.DataFrame(index=lob_df.index)

    bid_sz = lob_df[[f"bid_sz_{i}" for i in range(1, levels+1)]]
    ask_sz = lob_df[[f"ask_sz_{i}" for i in range(1, levels+1)]]

    # 1) 多档失衡
    tot_bid, tot_ask = bid_sz.sum(axis=1), ask_sz.sum(axis=1)
    feats["ofi"] = (tot_bid - tot_ask) / (tot_bid + tot_ask + 1e-9)

    # 2) 近端(第1档)失衡
    feats["ofi_l1"] = ((bid_sz.iloc[:, 0] - ask_sz.iloc[:, 0]) /
                       (bid_sz.iloc[:, 0] + ask_sz.iloc[:, 0] + 1e-9))

    # 3) 价差(以 tick 计)
    feats["spread"] = lob_df["ask_px_1"] - lob_df["bid_px_1"]

    # 4) 中价与微价差异(micro-price 偏移)
    mid = (lob_df["ask_px_1"] + lob_df["bid_px_1"]) / 2
    micro = ((ask_sz.iloc[:, 0] * lob_df["bid_px_1"] +
              bid_sz.iloc[:, 0] * lob_df["ask_px_1"]) /
             (bid_sz.iloc[:, 0] + ask_sz.iloc[:, 0] + 1e-9))
    feats["micro_dev"] = (micro - mid) / mid

    # 5) 失衡的变化率(增量方向)
    feats["ofi_delta"] = feats["ofi"].diff().fillna(0)

    return feats.fillna(0)

import torch
import torch.nn as nn

class LOBLSTM(nn.Module):
    def __init__(self, n_features, hidden=64, n_layers=2, n_classes=3, dropout=0.3):
        super().__init__()
        self.lstm = nn.LSTM(
            input_size=n_features, hidden_size=hidden,
            num_layers=n_layers, batch_first=True,
            dropout=dropout if n_layers > 1 else 0.0,
        )
        self.head = nn.Sequential(
            nn.LayerNorm(hidden),
            nn.Linear(hidden, hidden // 2),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden // 2, n_classes),
        )

    def forward(self, x):
        # x: (batch, seq_len, n_features)
        out, (h_n, c_n) = self.lstm(x)
        last = out[:, -1, :]        # 取序列最后一步的隐状态
        return self.head(last)      # (batch, n_classes)

def train_model(model, train_loader, val_loader, epochs=30, lr=1e-3):
    device = "cuda" if torch.cuda.is_available() else "cpu"
    model.to(device)
    opt = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-5)
    # 类别不平衡时用加权交叉熵
    crit = nn.CrossEntropyLoss()
    best_val, patience, wait = 1e9, 5, 0

    for ep in range(epochs):
        model.train()
        for xb, yb in train_loader:
            xb, yb = xb.to(device), yb.to(device)
            opt.zero_grad()
            loss = crit(model(xb), yb)
            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # 梯度裁剪
            opt.step()

        # 验证 + 早停
        model.eval()
        val_loss = 0.0
        with torch.no_grad():
            for xb, yb in val_loader:
                xb, yb = xb.to(device), yb.to(device)
                val_loss += crit(model(xb), yb).item()
        val_loss /= len(val_loader)

        if val_loss < best_val:
            best_val, wait = val_loss, 0
            torch.save(model.state_dict(), "best_lob_lstm.pt")
        else:
            wait += 1
            if wait >= patience:
                print(f"早停于 epoch {ep}")
                break
    return model

def backtest_signal(signals, mid_price, fee_bps=0.8, impact_bps=0.0):
    """
    signals: 模型输出的方向 (-1/0/+1)
    fee_bps: 单边手续费(基点)
    返回含成本前后的净值
    """
    ret = mid_price.pct_change().shift(-1).fillna(0)  # 下一步收益
    pnl_gross = signals * ret

    # 换仓成本: 只在仓位变化时收取
    turnover = np.abs(np.diff(np.concatenate([[0], signals])))
    cost = turnover * (fee_bps + impact_bps) / 1e4
    pnl_net = pnl_gross - cost

    eq_gross = (1 + pnl_gross).cumprod()
    eq_net = (1 + pnl_net).cumprod()
    return eq_gross, eq_net