| """Compact encoder registry for ADMA representation-reuse pilots.""" |
|
|
| from __future__ import annotations |
|
|
| import math |
|
|
| import torch |
| from torch import nn |
|
|
|
|
| class MLPEncoder(nn.Module): |
| def __init__(self, latent_dim: int = 128): |
| super().__init__() |
| self.net = nn.Sequential( |
| nn.Flatten(), |
| nn.Linear(100 * 40, 512), |
| nn.GELU(), |
| nn.LayerNorm(512), |
| nn.Linear(512, latent_dim), |
| ) |
|
|
| def forward(self, x): |
| return self.net(x) |
|
|
|
|
| class CNNEncoder(nn.Module): |
| def __init__(self, latent_dim: int = 128): |
| super().__init__() |
| self.conv = nn.Sequential( |
| nn.Conv2d(1, 32, kernel_size=(5, 3), padding=(2, 1)), |
| nn.GELU(), |
| nn.MaxPool2d((2, 1)), |
| nn.Conv2d(32, 64, kernel_size=(5, 3), padding=(2, 1)), |
| nn.GELU(), |
| nn.AdaptiveAvgPool2d((8, 8)), |
| ) |
| self.proj = nn.Linear(64 * 8 * 8, latent_dim) |
|
|
| def forward(self, x): |
| z = self.conv(x.unsqueeze(1)) |
| return self.proj(z.flatten(1)) |
|
|
|
|
| class LSTMEncoder(nn.Module): |
| def __init__(self, latent_dim: int = 128, hidden_dim: int = 128): |
| super().__init__() |
| self.lstm = nn.LSTM(input_size=40, hidden_size=hidden_dim, num_layers=2, batch_first=True) |
| self.proj = nn.Linear(hidden_dim, latent_dim) |
|
|
| def forward(self, x): |
| _, (h, _) = self.lstm(x) |
| return self.proj(h[-1]) |
|
|
|
|
| class PositionalEncoding(nn.Module): |
| def __init__(self, d_model: int, max_len: int = 100): |
| super().__init__() |
| pos = torch.arange(max_len).float().unsqueeze(1) |
| div = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) |
| pe = torch.zeros(max_len, d_model) |
| pe[:, 0::2] = torch.sin(pos * div) |
| pe[:, 1::2] = torch.cos(pos * div) |
| self.register_buffer("pe", pe.unsqueeze(0)) |
|
|
| def forward(self, x): |
| return x + self.pe[:, : x.size(1)] |
|
|
|
|
| class TransformerEncoder(nn.Module): |
| def __init__(self, latent_dim: int = 128, d_model: int = 128, nhead: int = 8, layers: int = 2): |
| super().__init__() |
| self.in_proj = nn.Linear(40, d_model) |
| self.pos = PositionalEncoding(d_model) |
| layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.encoder = nn.TransformerEncoder(layer, num_layers=layers) |
| self.out = nn.Linear(d_model, latent_dim) |
|
|
| def forward(self, x): |
| h = self.encoder(self.pos(self.in_proj(x))) |
| return self.out(h.mean(dim=1)) |
|
|
|
|
| class LOBRepEncoder(nn.Module): |
| """Small structure-aware encoder used as the pilot LOB representation model.""" |
|
|
| def __init__(self, latent_dim: int = 128): |
| super().__init__() |
| self.price_encoder = TransformerEncoder(latent_dim=latent_dim // 2, d_model=96, nhead=4, layers=2) |
| self.volume_encoder = TransformerEncoder(latent_dim=latent_dim // 2, d_model=96, nhead=4, layers=2) |
| self.mix = nn.Sequential(nn.LayerNorm(latent_dim), nn.Linear(latent_dim, latent_dim), nn.GELU()) |
|
|
| def forward(self, x): |
| price = x[:, :, :20] |
| volume = x[:, :, 20:] |
| z = torch.cat([self.price_encoder(_pad_to_40(price)), self.volume_encoder(_pad_to_40(volume))], dim=1) |
| return self.mix(z) |
|
|
|
|
| def _pad_to_40(x): |
| return torch.nn.functional.pad(x, (0, 40 - x.size(-1))) |
|
|
|
|
| class LOBGridEncoder(nn.Module): |
| """LOB-specific encoder that keeps the time x level x field structure explicit. |
| |
| Each snapshot is represented as ten level tokens. A level token contains the |
| bid/ask prices and volumes at the same depth plus simple microstructure |
| relations such as same-level spread and volume-side difference. The encoder |
| first models within-snapshot level interactions, then models temporal |
| evolution across snapshots with multi-scale temporal filters and attention. |
| """ |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| level_layers: int = 1, |
| temporal_layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__() |
| self.levels = levels |
| self.seq_len = seq_len |
| self.token_proj = nn.Sequential( |
| nn.Linear(8, d_model), |
| nn.GELU(), |
| nn.LayerNorm(d_model), |
| ) |
| self.level_embedding = nn.Parameter(torch.randn(1, 1, levels, d_model) * 0.02) |
| level_layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.level_encoder = nn.TransformerEncoder(level_layer, num_layers=level_layers) |
| self.level_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.temporal_filters = nn.ModuleList( |
| [ |
| nn.Conv1d(d_model, d_model, kernel_size=kernel, padding=kernel // 2, groups=d_model) |
| for kernel in (3, 5, 9) |
| ] |
| ) |
| self.temporal_mix = nn.Sequential(nn.Linear(3 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.pos = PositionalEncoding(d_model, max_len=seq_len) |
| temporal_layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.temporal_encoder = nn.TransformerEncoder(temporal_layer, num_layers=temporal_layers) |
| self.time_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.out = nn.Sequential(nn.LayerNorm(d_model), nn.Linear(d_model, latent_dim)) |
|
|
| def sequence(self, x): |
| tokens = self._level_tokens(x) |
| bsz, steps, levels, _ = tokens.shape |
| h = self.token_proj(tokens) + self.level_embedding[:, :, :levels] |
| dim = h.size(-1) |
| h = self.level_encoder(h.view(bsz * steps, levels, dim)) |
| level_weights = torch.softmax(self.level_score(h).squeeze(-1), dim=-1) |
| snapshots = torch.sum(h * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, dim) |
|
|
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
| def forward(self, x): |
| temporal = self.sequence(x) |
| time_weights = torch.softmax(self.time_score(temporal).squeeze(-1), dim=-1) |
| pooled = torch.sum(temporal * time_weights.unsqueeze(-1), dim=1) |
| return self.out(pooled) |
|
|
| def _level_tokens(self, x): |
| bid_p = x[:, :, :10].flip(-1) |
| ask_p = x[:, :, 10:20] |
| bid_v = x[:, :, 20:30].flip(-1) |
| ask_v = x[:, :, 30:40] |
| best_mid = 0.5 * (bid_p[:, :, :1] + ask_p[:, :, :1]) |
| same_level_spread = ask_p - bid_p |
| bid_distance = best_mid - bid_p |
| ask_distance = ask_p - best_mid |
| volume_diff = bid_v - ask_v |
| volume_sum = bid_v + ask_v |
| volume_imbalance = volume_diff / (torch.abs(volume_sum) + 1e-6) |
| return torch.stack( |
| [bid_p, ask_p, bid_v, ask_v, same_level_spread, bid_distance, ask_distance, volume_imbalance], |
| dim=-1, |
| ) |
|
|
|
|
| def lob_grid_fields(x: torch.Tensor) -> torch.Tensor: |
| """Return B x T x L x F with fields [bid_p, ask_p, bid_v, ask_v].""" |
|
|
| bid_p = x[:, :, :10].flip(-1) |
| ask_p = x[:, :, 10:20] |
| bid_v = x[:, :, 20:30].flip(-1) |
| ask_v = x[:, :, 30:40] |
| return torch.stack([bid_p, ask_p, bid_v, ask_v], dim=-1) |
|
|
|
|
| class LOBConvGridEncoder(nn.Module): |
| """Interpretable LOB encoder based on field, level, and temporal convolutions. |
| |
| The first convolution only sees the four fields within one level |
| (bid price, ask price, bid volume, ask volume). The second convolution only |
| sees neighboring levels. Temporal filters then model short and medium |
| horizon dynamics before a small Transformer aggregates the window. |
| """ |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| temporal_layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__() |
| self.levels = levels |
| self.field_conv = nn.Sequential( |
| nn.Conv2d(1, d_model, kernel_size=(1, 4)), |
| nn.GELU(), |
| nn.GroupNorm(num_groups=8, num_channels=d_model), |
| ) |
| self.neighbor_level_conv = nn.Sequential( |
| nn.Conv1d(d_model, d_model, kernel_size=3, padding=1, groups=d_model), |
| nn.GELU(), |
| nn.Conv1d(d_model, d_model, kernel_size=1), |
| nn.GELU(), |
| ) |
| self.level_embedding = nn.Parameter(torch.randn(1, levels, d_model) * 0.02) |
| prior = torch.pow(torch.full((levels,), 0.82), torch.arange(levels).float()) |
| self.register_buffer("level_prior", torch.log(prior / prior.sum()).view(1, levels)) |
| self.level_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
|
|
| self.micro_proj = nn.Sequential(nn.Linear(8, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.temporal_filters = nn.ModuleList( |
| [ |
| nn.Conv1d(d_model, d_model, kernel_size=kernel, padding=kernel // 2, groups=d_model) |
| for kernel in (3, 5, 9) |
| ] |
| ) |
| self.temporal_mix = nn.Sequential(nn.Linear(3 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.pos = PositionalEncoding(d_model, max_len=seq_len) |
| temporal_layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.temporal_encoder = nn.TransformerEncoder(temporal_layer, num_layers=temporal_layers) |
| self.time_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.out = nn.Sequential(nn.LayerNorm(d_model), nn.Linear(d_model, latent_dim)) |
|
|
| def sequence(self, x): |
| grid = lob_grid_fields(x) |
| bsz, steps, levels, fields = grid.shape |
| level_state = self.field_conv(grid.reshape(bsz * steps, 1, levels, fields)).squeeze(-1) |
| level_state = level_state + self.neighbor_level_conv(level_state) |
| level_state = level_state.transpose(1, 2) + self.level_embedding[:, :levels] |
| level_logits = self.level_score(level_state).squeeze(-1) + self.level_prior[:, :levels] |
| level_weights = torch.softmax(level_logits, dim=-1) |
| snapshots = torch.sum(level_state * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| snapshots = snapshots + self.micro_proj(self._micro_features(grid)) |
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
| def forward(self, x): |
| temporal = self.sequence(x) |
| time_weights = torch.softmax(self.time_score(temporal).squeeze(-1), dim=-1) |
| pooled = torch.sum(temporal * time_weights.unsqueeze(-1), dim=1) |
| return self.out(pooled) |
|
|
| def _micro_features(self, grid): |
| bid_p, ask_p, bid_v, ask_v = [grid[..., i] for i in range(4)] |
| best_bid = bid_p[:, :, :1] |
| best_ask = ask_p[:, :, :1] |
| spread = best_ask - best_bid |
| mid = 0.5 * (best_bid + best_ask) |
| mid_delta = torch.cat([torch.zeros_like(mid[:, :1]), mid[:, 1:] - mid[:, :-1]], dim=1) |
| top3_bid = bid_v[:, :, :3].sum(dim=-1, keepdim=True) |
| top3_ask = ask_v[:, :, :3].sum(dim=-1, keepdim=True) |
| all_bid = bid_v.sum(dim=-1, keepdim=True) |
| all_ask = ask_v.sum(dim=-1, keepdim=True) |
| return torch.cat( |
| [ |
| best_bid, |
| best_ask, |
| bid_v[:, :, :1], |
| ask_v[:, :, :1], |
| spread, |
| mid_delta, |
| top3_bid - top3_ask, |
| all_bid - all_ask, |
| ], |
| dim=-1, |
| ) |
|
|
|
|
| class TLOB2025Encoder(nn.Module): |
| """Dual-attention LOB encoder inspired by 2025 TLOB-style trend models.""" |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| spatial_layers: int = 1, |
| temporal_layers: int = 2, |
| seq_len: int = 100, |
| features: int = 40, |
| ): |
| super().__init__() |
| self.features = features |
| self.feature_proj = nn.Linear(1, d_model) |
| self.feature_embedding = nn.Parameter(torch.randn(1, features, d_model) * 0.02) |
| spatial_layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.spatial_encoder = nn.TransformerEncoder(spatial_layer, num_layers=spatial_layers) |
| self.spatial_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.pos = PositionalEncoding(d_model, max_len=seq_len) |
| temporal_layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.temporal_encoder = nn.TransformerEncoder(temporal_layer, num_layers=temporal_layers) |
| self.time_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.out = nn.Sequential(nn.LayerNorm(d_model), nn.Linear(d_model, latent_dim)) |
|
|
| def sequence(self, x): |
| bsz, steps, features = x.shape |
| h = self.feature_proj(x.reshape(bsz * steps, features, 1)) + self.feature_embedding[:, :features] |
| h = self.spatial_encoder(h) |
| spatial_weights = torch.softmax(self.spatial_score(h).squeeze(-1), dim=-1) |
| snapshots = torch.sum(h * spatial_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
| def forward(self, x): |
| temporal = self.sequence(x) |
| time_weights = torch.softmax(self.time_score(temporal).squeeze(-1), dim=-1) |
| pooled = torch.sum(temporal * time_weights.unsqueeze(-1), dim=1) |
| return self.out(pooled) |
|
|
|
|
| class SimLOBStyleEncoder(nn.Module): |
| """Vectorized LOB encoder inspired by SimLOB-style calibration representations.""" |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| seq_len: int = 100, |
| ): |
| super().__init__() |
| self.snapshot_vectorizer = nn.Sequential( |
| nn.Linear(40, 4 * d_model), |
| nn.GELU(), |
| nn.LayerNorm(4 * d_model), |
| nn.Linear(4 * d_model, d_model), |
| nn.GELU(), |
| nn.LayerNorm(d_model), |
| ) |
| self.pos = PositionalEncoding(d_model, max_len=seq_len) |
| layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.temporal_encoder = nn.TransformerEncoder(layer, num_layers=layers) |
| self.time_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.out = nn.Sequential(nn.LayerNorm(d_model), nn.Linear(d_model, latent_dim)) |
|
|
| def sequence(self, x): |
| return self.temporal_encoder(self.pos(self.snapshot_vectorizer(x))) |
|
|
| def forward(self, x): |
| temporal = self.sequence(x) |
| time_weights = torch.softmax(self.time_score(temporal).squeeze(-1), dim=-1) |
| pooled = torch.sum(temporal * time_weights.unsqueeze(-1), dim=1) |
| return self.out(pooled) |
|
|
|
|
| class LOBShapeSimLOBEncoder(nn.Module): |
| """SimLOB-style encoder with explicit LOB shape features. |
| |
| SimLOB showed that a strong fully connected snapshot vectorizer is effective |
| for LOB reconstruction. This encoder keeps that vectorizer, but adds a |
| lightweight shape branch before temporal attention: one kernel mixes the four |
| fields in each level, another kernel mixes neighboring levels, and explicit |
| spread/imbalance features keep the learned representation tied to LOB rules. |
| """ |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__() |
| self.levels = levels |
| self.snapshot_vectorizer = nn.Sequential( |
| nn.Linear(40, 4 * d_model), |
| nn.GELU(), |
| nn.LayerNorm(4 * d_model), |
| nn.Linear(4 * d_model, d_model), |
| nn.GELU(), |
| nn.LayerNorm(d_model), |
| ) |
| self.field_conv = nn.Sequential( |
| nn.Conv2d(1, d_model, kernel_size=(1, 4)), |
| nn.GELU(), |
| nn.GroupNorm(num_groups=8, num_channels=d_model), |
| ) |
| self.neighbor_level_conv = nn.Sequential( |
| nn.Conv1d(d_model, d_model, kernel_size=3, padding=1, groups=d_model), |
| nn.GELU(), |
| nn.Conv1d(d_model, d_model, kernel_size=1), |
| nn.GELU(), |
| ) |
| prior = torch.pow(torch.full((levels,), 0.86), torch.arange(levels).float()) |
| self.register_buffer("level_prior", torch.log(prior / prior.sum()).view(1, levels)) |
| self.level_embedding = nn.Parameter(torch.randn(1, levels, d_model) * 0.02) |
| self.level_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.micro_proj = nn.Sequential(nn.Linear(10, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.fuse = nn.Sequential(nn.Linear(3 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.temporal_filters = nn.ModuleList( |
| [ |
| nn.Conv1d(d_model, d_model, kernel_size=kernel, padding=kernel // 2, groups=d_model) |
| for kernel in (3, 5, 9) |
| ] |
| ) |
| self.temporal_mix = nn.Sequential(nn.Linear(3 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.pos = PositionalEncoding(d_model, max_len=seq_len) |
| layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.temporal_encoder = nn.TransformerEncoder(layer, num_layers=layers) |
| self.time_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.out = nn.Sequential(nn.LayerNorm(d_model), nn.Linear(d_model, latent_dim)) |
|
|
| def sequence(self, x): |
| raw_state = self.snapshot_vectorizer(x) |
| grid = lob_grid_fields(x) |
| bsz, steps, levels, fields = grid.shape |
| level_state = self.field_conv(grid.reshape(bsz * steps, 1, levels, fields)).squeeze(-1) |
| level_state = level_state + self.neighbor_level_conv(level_state) |
| level_state = level_state.transpose(1, 2) + self.level_embedding[:, :levels] |
| level_logits = self.level_score(level_state).squeeze(-1) + self.level_prior[:, :levels] |
| level_weights = torch.softmax(level_logits, dim=-1) |
| shape_state = torch.sum(level_state * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| snapshots = self.fuse(torch.cat([raw_state, shape_state, self.micro_proj(self._micro_features(grid))], dim=-1)) |
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
| def forward(self, x): |
| temporal = self.sequence(x) |
| time_weights = torch.softmax(self.time_score(temporal).squeeze(-1), dim=-1) |
| pooled = torch.sum(temporal * time_weights.unsqueeze(-1), dim=1) |
| return self.out(pooled) |
|
|
| def _micro_features(self, grid): |
| bid_p, ask_p, bid_v, ask_v = [grid[..., i] for i in range(4)] |
| best_bid = bid_p[:, :, :1] |
| best_ask = ask_p[:, :, :1] |
| spread = best_ask - best_bid |
| mid = 0.5 * (best_bid + best_ask) |
| mid_delta = torch.cat([torch.zeros_like(mid[:, :1]), mid[:, 1:] - mid[:, :-1]], dim=1) |
| top3_bid = bid_v[:, :, :3].sum(dim=-1, keepdim=True) |
| top3_ask = ask_v[:, :, :3].sum(dim=-1, keepdim=True) |
| all_bid = bid_v.sum(dim=-1, keepdim=True) |
| all_ask = ask_v.sum(dim=-1, keepdim=True) |
| price_slope_bid = bid_p[:, :, :1] - bid_p[:, :, -1:] |
| price_slope_ask = ask_p[:, :, -1:] - ask_p[:, :, :1] |
| top3_imbalance = (top3_bid - top3_ask) / (torch.abs(top3_bid + top3_ask) + 1e-6) |
| all_imbalance = (all_bid - all_ask) / (torch.abs(all_bid + all_ask) + 1e-6) |
| return torch.cat( |
| [ |
| best_bid, |
| best_ask, |
| spread, |
| mid_delta, |
| bid_v[:, :, :1], |
| ask_v[:, :, :1], |
| top3_imbalance, |
| all_imbalance, |
| price_slope_bid, |
| price_slope_ask, |
| ], |
| dim=-1, |
| ) |
|
|
|
|
| class LOBShapeWideSimLOBEncoder(LOBShapeSimLOBEncoder): |
| """LOB-shape SimLOB with multi-scale neighboring-level convolutions.""" |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__( |
| latent_dim=latent_dim, |
| d_model=d_model, |
| nhead=nhead, |
| layers=layers, |
| levels=levels, |
| seq_len=seq_len, |
| ) |
| self.level_filters = nn.ModuleList( |
| [ |
| nn.Conv1d(d_model, d_model, kernel_size=kernel, padding=kernel // 2, groups=d_model) |
| for kernel in (3, 5, 9) |
| ] |
| ) |
| self.level_mix = nn.Sequential(nn.Linear(3 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
|
|
| def sequence(self, x): |
| raw_state = self.snapshot_vectorizer(x) |
| grid = lob_grid_fields(x) |
| bsz, steps, levels, fields = grid.shape |
| level_state = self.field_conv(grid.reshape(bsz * steps, 1, levels, fields)).squeeze(-1) |
| multiscale = torch.cat([conv(level_state).transpose(1, 2) for conv in self.level_filters], dim=-1) |
| level_state = self.level_mix(multiscale) + self.level_embedding[:, :levels] |
| level_logits = self.level_score(level_state).squeeze(-1) + self.level_prior[:, :levels] |
| level_weights = torch.softmax(level_logits, dim=-1) |
| shape_state = torch.sum(level_state * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| snapshots = self.fuse(torch.cat([raw_state, shape_state, self.micro_proj(self._micro_features(grid))], dim=-1)) |
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
|
|
| class LOBShapeLevelSimLOBEncoder(LOBShapeSimLOBEncoder): |
| """LOB-shape SimLOB with a level Transformer after local level kernels. |
| |
| The shape branch first applies the interpretable same-level field kernel and |
| neighboring-level kernel from LOBShapeSimLOB. It then lets the ten depth |
| levels communicate through a small Transformer inside each snapshot. This |
| keeps the inductive bias local at the bottom of the encoder, while allowing |
| non-local depth relations such as near-touch pressure versus far-depth |
| liquidity to be learned before temporal aggregation. |
| """ |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__( |
| latent_dim=latent_dim, |
| d_model=d_model, |
| nhead=nhead, |
| layers=layers, |
| levels=levels, |
| seq_len=seq_len, |
| ) |
| level_layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.level_encoder = nn.TransformerEncoder(level_layer, num_layers=1) |
|
|
| def sequence(self, x): |
| raw_state = self.snapshot_vectorizer(x) |
| grid = lob_grid_fields(x) |
| bsz, steps, levels, fields = grid.shape |
| level_state = self.field_conv(grid.reshape(bsz * steps, 1, levels, fields)).squeeze(-1) |
| level_state = level_state + self.neighbor_level_conv(level_state) |
| level_state = level_state.transpose(1, 2) + self.level_embedding[:, :levels] |
| level_state = self.level_encoder(level_state) |
| level_logits = self.level_score(level_state).squeeze(-1) + self.level_prior[:, :levels] |
| level_weights = torch.softmax(level_logits, dim=-1) |
| shape_state = torch.sum(level_state * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| snapshots = self.fuse(torch.cat([raw_state, shape_state, self.micro_proj(self._micro_features(grid))], dim=-1)) |
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
|
|
| class LOBShapeStructuredLevelSimLOBEncoder(LOBShapeLevelSimLOBEncoder): |
| """Level-SimLOB with explicit per-level price-volume relation tokens. |
| |
| The w3 model learns the same-level field kernel directly from the four raw |
| fields. This variant keeps the SimLOB raw snapshot branch, but makes the |
| level branch more interpretable by projecting hand-specified LOB relations |
| at each depth level before neighboring-level convolution and level attention. |
| """ |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__( |
| latent_dim=latent_dim, |
| d_model=d_model, |
| nhead=nhead, |
| layers=layers, |
| levels=levels, |
| seq_len=seq_len, |
| ) |
| self.level_relation_proj = nn.Sequential(nn.Linear(12, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| level_pos = torch.linspace(0.0, 1.0, levels).view(1, 1, levels) |
| self.register_buffer("level_position", level_pos) |
|
|
| def sequence(self, x): |
| raw_state = self.snapshot_vectorizer(x) |
| grid = lob_grid_fields(x) |
| bsz, steps, levels, _ = grid.shape |
|
|
| relation_tokens = self._level_relation_tokens(grid) |
| level_state = self.level_relation_proj(relation_tokens.reshape(bsz * steps, levels, -1)) |
| local_state = self.neighbor_level_conv(level_state.transpose(1, 2)).transpose(1, 2) |
| level_state = level_state + local_state + self.level_embedding[:, :levels] |
| level_state = self.level_encoder(level_state) |
| level_logits = self.level_score(level_state).squeeze(-1) + self.level_prior[:, :levels] |
| level_weights = torch.softmax(level_logits, dim=-1) |
| shape_state = torch.sum(level_state * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| snapshots = self.fuse(torch.cat([raw_state, shape_state, self.micro_proj(self._micro_features(grid))], dim=-1)) |
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
| def _level_relation_tokens(self, grid): |
| bid_p, ask_p, bid_v, ask_v = [grid[..., i] for i in range(4)] |
| best_bid = bid_p[:, :, :1] |
| best_ask = ask_p[:, :, :1] |
| touch_mid = 0.5 * (best_bid + best_ask) |
| level_mid = 0.5 * (bid_p + ask_p) |
| same_level_spread = ask_p - bid_p |
| bid_distance = best_bid - bid_p |
| ask_distance = ask_p - best_ask |
| depth_sum = bid_v + ask_v |
| depth_diff = bid_v - ask_v |
| depth_imbalance = depth_diff / (torch.abs(depth_sum) + 1e-6) |
| mid_distance = torch.abs(level_mid - touch_mid) |
| level_position = self.level_position[:, :, : bid_p.size(-1)].expand_as(bid_p) |
| return torch.stack( |
| [ |
| bid_p, |
| ask_p, |
| bid_v, |
| ask_v, |
| same_level_spread, |
| bid_distance, |
| ask_distance, |
| mid_distance, |
| depth_sum, |
| depth_diff, |
| depth_imbalance, |
| level_position, |
| ], |
| dim=-1, |
| ) |
|
|
|
|
| class LOBShapeHybridLevelSimLOBEncoder(LOBShapeLevelSimLOBEncoder): |
| """Level-SimLOB with learned local kernels plus explicit relation tokens. |
| |
| The structured w4 variant made the level branch easier to explain by |
| replacing the learned same-level field kernel with hand-specified |
| price-volume relations. This hybrid variant keeps the stronger learned |
| field and neighboring-level kernels from w3, then adds the explicit |
| relation branch as an auxiliary view. The two views are pooled separately |
| before fusion, so the model can use interpretable spread, distance, and |
| imbalance cues without losing raw same-level pattern capacity. |
| """ |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__( |
| latent_dim=latent_dim, |
| d_model=d_model, |
| nhead=nhead, |
| layers=layers, |
| levels=levels, |
| seq_len=seq_len, |
| ) |
| self.relation_proj = nn.Sequential(nn.Linear(12, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.relation_encoder = nn.TransformerEncoder( |
| nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ), |
| num_layers=1, |
| ) |
| self.relation_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| level_pos = torch.linspace(0.0, 1.0, levels).view(1, 1, levels) |
| self.register_buffer("level_position", level_pos) |
| self.fuse = nn.Sequential(nn.Linear(4 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
|
|
| def sequence(self, x): |
| raw_state = self.snapshot_vectorizer(x) |
| grid = lob_grid_fields(x) |
| bsz, steps, levels, fields = grid.shape |
|
|
| level_state = self.field_conv(grid.reshape(bsz * steps, 1, levels, fields)).squeeze(-1) |
| level_state = level_state + self.neighbor_level_conv(level_state) |
| level_state = level_state.transpose(1, 2) + self.level_embedding[:, :levels] |
| level_state = self.level_encoder(level_state) |
| level_logits = self.level_score(level_state).squeeze(-1) + self.level_prior[:, :levels] |
| level_weights = torch.softmax(level_logits, dim=-1) |
| learned_shape = torch.sum(level_state * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| relation_tokens = self._level_relation_tokens(grid) |
| relation_state = self.relation_proj(relation_tokens.reshape(bsz * steps, levels, -1)) |
| relation_state = relation_state + self.level_embedding[:, :levels] |
| relation_state = self.relation_encoder(relation_state) |
| relation_logits = self.relation_score(relation_state).squeeze(-1) + self.level_prior[:, :levels] |
| relation_weights = torch.softmax(relation_logits, dim=-1) |
| relation_shape = torch.sum(relation_state * relation_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| snapshots = self.fuse( |
| torch.cat([raw_state, learned_shape, relation_shape, self.micro_proj(self._micro_features(grid))], dim=-1) |
| ) |
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
| def _level_relation_tokens(self, grid): |
| bid_p, ask_p, bid_v, ask_v = [grid[..., i] for i in range(4)] |
| best_bid = bid_p[:, :, :1] |
| best_ask = ask_p[:, :, :1] |
| touch_mid = 0.5 * (best_bid + best_ask) |
| level_mid = 0.5 * (bid_p + ask_p) |
| same_level_spread = ask_p - bid_p |
| bid_distance = best_bid - bid_p |
| ask_distance = ask_p - best_ask |
| depth_sum = bid_v + ask_v |
| depth_diff = bid_v - ask_v |
| depth_imbalance = depth_diff / (torch.abs(depth_sum) + 1e-6) |
| mid_distance = torch.abs(level_mid - touch_mid) |
| level_position = self.level_position[:, :, : bid_p.size(-1)].expand_as(bid_p) |
| return torch.stack( |
| [ |
| bid_p, |
| ask_p, |
| bid_v, |
| ask_v, |
| same_level_spread, |
| bid_distance, |
| ask_distance, |
| mid_distance, |
| depth_sum, |
| depth_diff, |
| depth_imbalance, |
| level_position, |
| ], |
| dim=-1, |
| ) |
|
|
|
|
| class LOBShapeFlowSimLOBEncoder(LOBShapeSimLOBEncoder): |
| """LOB-shape SimLOB with an explicit order-flow branch. |
| |
| The original shape branch compresses within-snapshot level geometry. This |
| variant adds signed short-horizon microstructure changes: best-price moves, |
| spread changes, normalized order-flow imbalance, and depth/imbalance deltas. |
| These features target the part of LOB representation that matters most for |
| trend labels while keeping the SimLOB-style reconstruction path intact. |
| """ |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__( |
| latent_dim=latent_dim, |
| d_model=d_model, |
| nhead=nhead, |
| layers=layers, |
| levels=levels, |
| seq_len=seq_len, |
| ) |
| self.flow_proj = nn.Sequential(nn.Linear(12, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.fuse = nn.Sequential(nn.Linear(4 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
|
|
| def sequence(self, x): |
| raw_state = self.snapshot_vectorizer(x) |
| grid = lob_grid_fields(x) |
| bsz, steps, levels, fields = grid.shape |
| level_state = self.field_conv(grid.reshape(bsz * steps, 1, levels, fields)).squeeze(-1) |
| level_state = level_state + self.neighbor_level_conv(level_state) |
| level_state = level_state.transpose(1, 2) + self.level_embedding[:, :levels] |
| level_logits = self.level_score(level_state).squeeze(-1) + self.level_prior[:, :levels] |
| level_weights = torch.softmax(level_logits, dim=-1) |
| shape_state = torch.sum(level_state * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| snapshots = self.fuse( |
| torch.cat( |
| [ |
| raw_state, |
| shape_state, |
| self.micro_proj(self._micro_features(grid)), |
| self.flow_proj(self._flow_features(grid)), |
| ], |
| dim=-1, |
| ) |
| ) |
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
| def _flow_features(self, grid): |
| bid_p, ask_p, bid_v, ask_v = [grid[..., i] for i in range(4)] |
| prev_bid_p = torch.cat([bid_p[:, :1], bid_p[:, :-1]], dim=1) |
| prev_ask_p = torch.cat([ask_p[:, :1], ask_p[:, :-1]], dim=1) |
| prev_bid_v = torch.cat([bid_v[:, :1], bid_v[:, :-1]], dim=1) |
| prev_ask_v = torch.cat([ask_v[:, :1], ask_v[:, :-1]], dim=1) |
|
|
| bid_event = (bid_p >= prev_bid_p).to(bid_p.dtype) * bid_v - (bid_p <= prev_bid_p).to(bid_p.dtype) * prev_bid_v |
| ask_event = (ask_p <= prev_ask_p).to(ask_p.dtype) * ask_v - (ask_p >= prev_ask_p).to(ask_p.dtype) * prev_ask_v |
| ofi = bid_event - ask_event |
|
|
| best_bid = bid_p[:, :, :1] |
| best_ask = ask_p[:, :, :1] |
| prev_best_bid = prev_bid_p[:, :, :1] |
| prev_best_ask = prev_ask_p[:, :, :1] |
| mid = 0.5 * (best_bid + best_ask) |
| prev_mid = 0.5 * (prev_best_bid + prev_best_ask) |
| spread = best_ask - best_bid |
| prev_spread = prev_best_ask - prev_best_bid |
|
|
| top1_bid = bid_v[:, :, :1] |
| top1_ask = ask_v[:, :, :1] |
| top3_bid = bid_v[:, :, :3].sum(dim=-1, keepdim=True) |
| top3_ask = ask_v[:, :, :3].sum(dim=-1, keepdim=True) |
| all_bid = bid_v.sum(dim=-1, keepdim=True) |
| all_ask = ask_v.sum(dim=-1, keepdim=True) |
| prev_top1_bid = prev_bid_v[:, :, :1] |
| prev_top1_ask = prev_ask_v[:, :, :1] |
| prev_top3_bid = prev_bid_v[:, :, :3].sum(dim=-1, keepdim=True) |
| prev_top3_ask = prev_ask_v[:, :, :3].sum(dim=-1, keepdim=True) |
| prev_all_bid = prev_bid_v.sum(dim=-1, keepdim=True) |
| prev_all_ask = prev_ask_v.sum(dim=-1, keepdim=True) |
|
|
| def imbalance(bid, ask): |
| return (bid - ask) / (torch.abs(bid + ask) + 1e-6) |
|
|
| def normalized_ofi(values, bid, ask): |
| return values / (torch.abs(bid + ask) + 1e-6) |
|
|
| top1_ofi = normalized_ofi(ofi[:, :, :1], top1_bid, top1_ask) |
| top3_ofi = normalized_ofi(ofi[:, :, :3].sum(dim=-1, keepdim=True), top3_bid, top3_ask) |
| all_ofi = normalized_ofi(ofi.sum(dim=-1, keepdim=True), all_bid, all_ask) |
| top1_imb_delta = imbalance(top1_bid, top1_ask) - imbalance(prev_top1_bid, prev_top1_ask) |
| top3_imb_delta = imbalance(top3_bid, top3_ask) - imbalance(prev_top3_bid, prev_top3_ask) |
| all_imb_delta = imbalance(all_bid, all_ask) - imbalance(prev_all_bid, prev_all_ask) |
| top3_depth_delta = (top3_bid + top3_ask) - (prev_top3_bid + prev_top3_ask) |
| all_depth_delta = (all_bid + all_ask) - (prev_all_bid + prev_all_ask) |
|
|
| return torch.cat( |
| [ |
| best_bid - prev_best_bid, |
| best_ask - prev_best_ask, |
| mid - prev_mid, |
| spread - prev_spread, |
| top1_ofi, |
| top3_ofi, |
| all_ofi, |
| top1_imb_delta, |
| top3_imb_delta, |
| all_imb_delta, |
| top3_depth_delta, |
| all_depth_delta, |
| ], |
| dim=-1, |
| ) |
|
|
|
|
| class LOBShapeFlowLevelSimLOBEncoder(LOBShapeLevelSimLOBEncoder): |
| """Level-SimLOB with an explicit order-flow branch. |
| |
| This variant keeps the w3 level-shape path, where same-level field kernels |
| and neighboring-level kernels are followed by a level Transformer. It adds |
| a signed flow branch for best-price moves, spread changes, order-flow |
| imbalance, and depth/imbalance deltas, so the encoder can preserve LOB |
| geometry while exposing short-horizon pressure signals for trend tasks. |
| """ |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__( |
| latent_dim=latent_dim, |
| d_model=d_model, |
| nhead=nhead, |
| layers=layers, |
| levels=levels, |
| seq_len=seq_len, |
| ) |
| self.flow_proj = nn.Sequential(nn.Linear(12, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.fuse = nn.Sequential(nn.Linear(4 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
|
|
| def sequence(self, x): |
| raw_state = self.snapshot_vectorizer(x) |
| grid = lob_grid_fields(x) |
| bsz, steps, levels, fields = grid.shape |
|
|
| level_state = self.field_conv(grid.reshape(bsz * steps, 1, levels, fields)).squeeze(-1) |
| level_state = level_state + self.neighbor_level_conv(level_state) |
| level_state = level_state.transpose(1, 2) + self.level_embedding[:, :levels] |
| level_state = self.level_encoder(level_state) |
| level_logits = self.level_score(level_state).squeeze(-1) + self.level_prior[:, :levels] |
| level_weights = torch.softmax(level_logits, dim=-1) |
| shape_state = torch.sum(level_state * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| snapshots = self.fuse( |
| torch.cat( |
| [ |
| raw_state, |
| shape_state, |
| self.micro_proj(self._micro_features(grid)), |
| self.flow_proj(self._flow_features(grid)), |
| ], |
| dim=-1, |
| ) |
| ) |
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
| _flow_features = LOBShapeFlowSimLOBEncoder._flow_features |
|
|
|
|
| class LOBShapeGatedFlowLevelSimLOBEncoder(LOBShapeLevelSimLOBEncoder): |
| """Level-SimLOB with gated order-flow residual injection. |
| |
| Flow-level concatenation can improve downstream adaptation, but a scratch |
| trend classifier may overreact to noisy short-horizon flow. This variant |
| keeps the level-shape snapshot as the main state and injects order-flow |
| features through a learned gate. The gate is computed from both the current |
| LOB shape and the flow signal, so the model can retain static depth |
| geometry when flow is uninformative and amplify signed pressure when it is |
| useful. |
| """ |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__( |
| latent_dim=latent_dim, |
| d_model=d_model, |
| nhead=nhead, |
| layers=layers, |
| levels=levels, |
| seq_len=seq_len, |
| ) |
| self.flow_proj = nn.Sequential(nn.Linear(12, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.flow_gate = nn.Sequential( |
| nn.Linear(2 * d_model, d_model), |
| nn.GELU(), |
| nn.Linear(d_model, d_model), |
| nn.Sigmoid(), |
| ) |
| self.flow_norm = nn.LayerNorm(d_model) |
|
|
| def sequence(self, x): |
| raw_state = self.snapshot_vectorizer(x) |
| grid = lob_grid_fields(x) |
| bsz, steps, levels, fields = grid.shape |
|
|
| level_state = self.field_conv(grid.reshape(bsz * steps, 1, levels, fields)).squeeze(-1) |
| level_state = level_state + self.neighbor_level_conv(level_state) |
| level_state = level_state.transpose(1, 2) + self.level_embedding[:, :levels] |
| level_state = self.level_encoder(level_state) |
| level_logits = self.level_score(level_state).squeeze(-1) + self.level_prior[:, :levels] |
| level_weights = torch.softmax(level_logits, dim=-1) |
| shape_state = torch.sum(level_state * level_weights.unsqueeze(-1), dim=1).view(bsz, steps, -1) |
|
|
| base_snapshot = self.fuse(torch.cat([raw_state, shape_state, self.micro_proj(self._micro_features(grid))], dim=-1)) |
| flow_state = self.flow_proj(self._flow_features(grid)) |
| flow_gate = self.flow_gate(torch.cat([base_snapshot, flow_state], dim=-1)) |
| snapshots = self.flow_norm(base_snapshot + flow_gate * flow_state) |
|
|
| conv_in = snapshots.transpose(1, 2) |
| multiscale = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| snapshots = snapshots + self.temporal_mix(multiscale) |
| return self.temporal_encoder(self.pos(snapshots)) |
|
|
| _flow_features = LOBShapeFlowSimLOBEncoder._flow_features |
|
|
|
|
| class LOBShapeGridFusionEncoder(nn.Module): |
| """Fuse SimLOB-style shape features with LOBGrid level-token dynamics.""" |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 96, |
| nhead: int = 4, |
| layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__() |
| self.shape = LOBShapeSimLOBEncoder( |
| latent_dim=latent_dim, |
| d_model=d_model, |
| nhead=nhead, |
| layers=layers, |
| levels=levels, |
| seq_len=seq_len, |
| ) |
| self.grid = LOBGridEncoder( |
| latent_dim=latent_dim, |
| d_model=d_model, |
| nhead=nhead, |
| temporal_layers=layers, |
| levels=levels, |
| seq_len=seq_len, |
| ) |
| self.fuse = nn.Sequential(nn.Linear(2 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.time_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.out = nn.Sequential(nn.LayerNorm(d_model), nn.Linear(d_model, latent_dim)) |
|
|
| def sequence(self, x): |
| return self.fuse(torch.cat([self.shape.sequence(x), self.grid.sequence(x)], dim=-1)) |
|
|
| def forward(self, x): |
| temporal = self.sequence(x) |
| time_weights = torch.softmax(self.time_score(temporal).squeeze(-1), dim=-1) |
| pooled = torch.sum(temporal * time_weights.unsqueeze(-1), dim=1) |
| return self.out(pooled) |
|
|
|
|
| class LOBStructEncoder(nn.Module): |
| """LOB encoder with explicit depth, touch-line, and temporal microstructure paths.""" |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 128, |
| nhead: int = 4, |
| level_layers: int = 1, |
| temporal_layers: int = 2, |
| levels: int = 10, |
| seq_len: int = 100, |
| ): |
| super().__init__() |
| self.levels = levels |
| self.token_proj = nn.Sequential(nn.Linear(8, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.level_embedding = nn.Parameter(torch.randn(1, 1, levels, d_model) * 0.02) |
| self.level_local = nn.Sequential( |
| nn.Conv2d(d_model, d_model, kernel_size=(1, 3), padding=(0, 1), groups=d_model), |
| nn.GELU(), |
| nn.Conv2d(d_model, d_model, kernel_size=1), |
| ) |
| level_layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.level_encoder = nn.TransformerEncoder(level_layer, num_layers=level_layers) |
| self.level_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| prior = torch.pow(torch.full((levels,), 0.82), torch.arange(levels).float()) |
| self.register_buffer("level_prior", torch.log(prior / prior.sum()).view(1, levels)) |
|
|
| self.micro_proj = nn.Sequential(nn.Linear(10, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.micro_filter = nn.Sequential( |
| nn.Conv1d(d_model, d_model, kernel_size=5, padding=2, groups=d_model), |
| nn.GELU(), |
| nn.Conv1d(d_model, d_model, kernel_size=1), |
| ) |
| self.temporal_filters = nn.ModuleList( |
| [ |
| nn.Conv1d(d_model, d_model, kernel_size=kernel, padding=kernel // 2, groups=d_model) |
| for kernel in (3, 5, 9, 15) |
| ] |
| ) |
| self.temporal_mix = nn.Sequential(nn.Linear(4 * d_model, d_model), nn.GELU(), nn.LayerNorm(d_model)) |
| self.gru = nn.GRU(d_model, d_model // 2, num_layers=1, batch_first=True, bidirectional=True) |
| self.pos = PositionalEncoding(d_model, max_len=seq_len) |
| temporal_layer = nn.TransformerEncoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| batch_first=True, |
| dropout=0.1, |
| activation="gelu", |
| ) |
| self.temporal_encoder = nn.TransformerEncoder(temporal_layer, num_layers=temporal_layers) |
| self.time_score = nn.Sequential(nn.Linear(d_model, d_model // 2), nn.GELU(), nn.Linear(d_model // 2, 1)) |
| self.out = nn.Sequential(nn.LayerNorm(d_model), nn.Linear(d_model, latent_dim)) |
|
|
| def sequence(self, x): |
| level_tokens, parts = self._level_tokens(x) |
| bsz, steps, levels, _ = level_tokens.shape |
| h = self.token_proj(level_tokens) + self.level_embedding[:, :, :levels] |
| local = self.level_local(h.permute(0, 3, 1, 2)).permute(0, 2, 3, 1) |
| h = h + local |
| dim = h.size(-1) |
| h = self.level_encoder(h.view(bsz * steps, levels, dim)) |
| logits = self.level_score(h).squeeze(-1) + self.level_prior[:, :levels] |
| weights = torch.softmax(logits, dim=-1) |
| depth_state = torch.sum(h * weights.unsqueeze(-1), dim=1).view(bsz, steps, dim) |
|
|
| micro = self.micro_proj(self._micro_features(parts)) |
| micro = micro + self.micro_filter(micro.transpose(1, 2)).transpose(1, 2) |
| states = depth_state + micro |
|
|
| conv_in = states.transpose(1, 2) |
| multi = torch.cat([conv(conv_in).transpose(1, 2) for conv in self.temporal_filters], dim=-1) |
| states = states + self.temporal_mix(multi) |
| gru_out, _ = self.gru(states) |
| return self.temporal_encoder(self.pos(states + gru_out)) |
|
|
| def forward(self, x): |
| temporal = self.sequence(x) |
| time_weights = torch.softmax(self.time_score(temporal).squeeze(-1), dim=-1) |
| pooled = torch.sum(temporal * time_weights.unsqueeze(-1), dim=1) |
| return self.out(pooled) |
|
|
| def _level_tokens(self, x): |
| bid_p = x[:, :, :10].flip(-1) |
| ask_p = x[:, :, 10:20] |
| bid_v = x[:, :, 20:30].flip(-1) |
| ask_v = x[:, :, 30:40] |
| best_mid = 0.5 * (bid_p[:, :, :1] + ask_p[:, :, :1]) |
| same_level_spread = ask_p - bid_p |
| mid_distance = torch.abs(0.5 * (bid_p + ask_p) - best_mid) |
| volume_diff = bid_v - ask_v |
| volume_sum = bid_v + ask_v |
| tokens = torch.stack( |
| [bid_p, ask_p, bid_v, ask_v, same_level_spread, mid_distance, volume_diff, volume_sum], |
| dim=-1, |
| ) |
| return tokens, { |
| "bid_p": bid_p, |
| "ask_p": ask_p, |
| "bid_v": bid_v, |
| "ask_v": ask_v, |
| "best_mid": best_mid, |
| } |
|
|
| def _micro_features(self, parts): |
| bid_p = parts["bid_p"] |
| ask_p = parts["ask_p"] |
| bid_v = parts["bid_v"] |
| ask_v = parts["ask_v"] |
| best_mid = parts["best_mid"] |
| spread = ask_p[:, :, :1] - bid_p[:, :, :1] |
| mid_delta = torch.cat([torch.zeros_like(best_mid[:, :1]), best_mid[:, 1:] - best_mid[:, :-1]], dim=1) |
| top3_bid = bid_v[:, :, :3].sum(dim=-1, keepdim=True) |
| top3_ask = ask_v[:, :, :3].sum(dim=-1, keepdim=True) |
| all_bid = bid_v.sum(dim=-1, keepdim=True) |
| all_ask = ask_v.sum(dim=-1, keepdim=True) |
| top3_diff = top3_bid - top3_ask |
| all_diff = all_bid - all_ask |
| top3_depth = top3_bid + top3_ask |
| all_depth = all_bid + all_ask |
| return torch.cat( |
| [ |
| bid_p[:, :, :1], |
| ask_p[:, :, :1], |
| bid_v[:, :, :1], |
| ask_v[:, :, :1], |
| spread, |
| mid_delta, |
| top3_diff, |
| all_diff, |
| top3_depth, |
| all_depth, |
| ], |
| dim=-1, |
| ) |
|
|
|
|
| def build_encoder(name: str, latent_dim: int): |
| registry = { |
| "mlp": MLPEncoder, |
| "cnn": CNNEncoder, |
| "lstm": LSTMEncoder, |
| "transformer": TransformerEncoder, |
| "lobrep": LOBRepEncoder, |
| "lobgrid": LOBGridEncoder, |
| "lobconv": LOBConvGridEncoder, |
| "lobstruct": LOBStructEncoder, |
| "lobstruct_timae_lobloss": LOBStructEncoder, |
| "tlob2025": TLOB2025Encoder, |
| "tlob2025_lobloss": TLOB2025Encoder, |
| "tlob2025_softlobloss": TLOB2025Encoder, |
| "simlob2026": SimLOBStyleEncoder, |
| "simlob2026_lobloss": SimLOBStyleEncoder, |
| "simlob2026_softlobloss": SimLOBStyleEncoder, |
| "timae_lobloss": TransformerEncoder, |
| "timae_softlobloss": TransformerEncoder, |
| "lobconv_timae_lobloss": LOBConvGridEncoder, |
| "lobconv_timae_softlobloss": LOBConvGridEncoder, |
| "lobgrid_timae_lobloss": LOBGridEncoder, |
| "lobgrid_timae_softlobloss": LOBGridEncoder, |
| "lobshape_simlob": LOBShapeSimLOBEncoder, |
| "lobshape_simlob_lobloss": LOBShapeSimLOBEncoder, |
| "lobshape_simlob_twostage_lobloss": LOBShapeSimLOBEncoder, |
| "lobshape_level_simlob": LOBShapeLevelSimLOBEncoder, |
| "lobshape_level_simlob_lobloss": LOBShapeLevelSimLOBEncoder, |
| "lobshape_structured_level_simlob": LOBShapeStructuredLevelSimLOBEncoder, |
| "lobshape_structured_level_simlob_lobloss": LOBShapeStructuredLevelSimLOBEncoder, |
| "lobshape_hybrid_level_simlob": LOBShapeHybridLevelSimLOBEncoder, |
| "lobshape_hybrid_level_simlob_lobloss": LOBShapeHybridLevelSimLOBEncoder, |
| "lobshape_wide_simlob": LOBShapeWideSimLOBEncoder, |
| "lobshape_wide_simlob_lobloss": LOBShapeWideSimLOBEncoder, |
| "lobshape_flow_simlob": LOBShapeFlowSimLOBEncoder, |
| "lobshape_flow_simlob_lobloss": LOBShapeFlowSimLOBEncoder, |
| "lobshape_flow_level_simlob": LOBShapeFlowLevelSimLOBEncoder, |
| "lobshape_flow_level_simlob_lobloss": LOBShapeFlowLevelSimLOBEncoder, |
| "lobshape_gated_flow_level_simlob": LOBShapeGatedFlowLevelSimLOBEncoder, |
| "lobshape_gated_flow_level_simlob_lobloss": LOBShapeGatedFlowLevelSimLOBEncoder, |
| "lobshape_gridfusion": LOBShapeGridFusionEncoder, |
| "lobshape_gridfusion_lobloss": LOBShapeGridFusionEncoder, |
| } |
| if name not in registry: |
| raise KeyError(f"Unknown model '{name}'. Available: {sorted(registry)}") |
| return registry[name](latent_dim=latent_dim) |
|
|
|
|
| class AutoEncoder(nn.Module): |
| def __init__( |
| self, |
| encoder: nn.Module, |
| latent_dim: int = 128, |
| decoder_name: str = "mlp", |
| decoder_layers: int = 2, |
| decoder_heads: int = 8, |
| decoder_d_model: int = 128, |
| ): |
| super().__init__() |
| self.encoder = encoder |
| if decoder_name == "mlp": |
| self.decoder = MLPDecoder(latent_dim=latent_dim) |
| elif decoder_name == "transformer": |
| self.decoder = QueryTransformerReconstructionDecoder( |
| latent_dim=latent_dim, |
| d_model=decoder_d_model, |
| nhead=decoder_heads, |
| layers=decoder_layers, |
| ) |
| elif decoder_name == "transformer_seq": |
| self.decoder = LatentSequenceTransformerDecoder( |
| latent_dim=latent_dim, |
| d_model=decoder_d_model, |
| nhead=decoder_heads, |
| layers=decoder_layers, |
| ) |
| else: |
| raise KeyError(f"Unknown reconstruction decoder '{decoder_name}'.") |
|
|
| def forward(self, x): |
| z = self.encoder(x) |
| return self.decoder(z) |
|
|
|
|
| class MLPDecoder(nn.Module): |
| def __init__(self, latent_dim: int = 128): |
| super().__init__() |
| self.net = nn.Sequential( |
| nn.Linear(latent_dim, 512), |
| nn.GELU(), |
| nn.Linear(512, 100 * 40), |
| ) |
|
|
| def forward(self, z): |
| return self.net(z).view(-1, 100, 40) |
|
|
|
|
| class QueryTransformerReconstructionDecoder(nn.Module): |
| """Transformer decoder with learned position queries and one latent memory token.""" |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 128, |
| nhead: int = 8, |
| layers: int = 2, |
| seq_len: int = 100, |
| out_dim: int = 40, |
| ): |
| super().__init__() |
| self.seq_len = seq_len |
| self.memory_proj = nn.Linear(latent_dim, d_model) |
| self.query = nn.Parameter(torch.randn(1, seq_len, d_model) * 0.02) |
| self.pos = PositionalEncoding(d_model, max_len=seq_len) |
| layer = nn.TransformerDecoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| dropout=0.1, |
| batch_first=True, |
| activation="gelu", |
| ) |
| self.decoder = nn.TransformerDecoder(layer, num_layers=layers) |
| self.out = nn.Linear(d_model, out_dim) |
|
|
| def forward(self, z): |
| memory = self.memory_proj(z).unsqueeze(1) |
| query = self.query.expand(z.size(0), -1, -1) |
| decoded = self.decoder(self.pos(query), memory) |
| return self.out(decoded) |
|
|
|
|
| class LatentSequenceTransformerDecoder(nn.Module): |
| """Stronger Transformer decoder seeded by a latent-conditioned token sequence.""" |
|
|
| def __init__( |
| self, |
| latent_dim: int = 128, |
| d_model: int = 128, |
| nhead: int = 8, |
| layers: int = 2, |
| seq_len: int = 100, |
| out_dim: int = 40, |
| ): |
| super().__init__() |
| self.seq_len = seq_len |
| self.d_model = d_model |
| self.memory_proj = nn.Linear(latent_dim, d_model) |
| self.seed = nn.Sequential( |
| nn.Linear(latent_dim, 4 * d_model), |
| nn.GELU(), |
| nn.Linear(4 * d_model, seq_len * d_model), |
| ) |
| self.pos = PositionalEncoding(d_model, max_len=seq_len) |
| layer = nn.TransformerDecoderLayer( |
| d_model=d_model, |
| nhead=nhead, |
| dim_feedforward=4 * d_model, |
| dropout=0.1, |
| batch_first=True, |
| activation="gelu", |
| ) |
| self.decoder = nn.TransformerDecoder(layer, num_layers=layers) |
| self.out = nn.Linear(d_model, out_dim) |
|
|
| def forward(self, z): |
| memory = self.memory_proj(z).unsqueeze(1) |
| tgt = self.seed(z).view(z.size(0), self.seq_len, self.d_model) |
| decoded = self.decoder(self.pos(tgt), memory) |
| return self.out(decoded) |
|
|
|
|
| class Classifier(nn.Module): |
| def __init__(self, encoder: nn.Module, latent_dim: int = 128, num_classes: int = 3): |
| super().__init__() |
| self.encoder = encoder |
| self.head = nn.Sequential(nn.LayerNorm(latent_dim), nn.Linear(latent_dim, num_classes)) |
|
|
| def forward(self, x): |
| return self.head(self.encoder(x)) |
|
|
