"""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))