| from __future__ import annotations |
|
|
| import torch |
| import torch.nn as nn |
| from torch_geometric.nn import TransformerConv |
|
|
|
|
| class TransformerGraphSpatialEncoder(nn.Module): |
| """Per-frame graph encoder using edge-aware PyG TransformerConv layers.""" |
|
|
| def __init__( |
| self, |
| node_in_dim: int, |
| edge_in_dim: int, |
| hidden_dim: int = 384, |
| num_layers: int = 6, |
| dropout: float = 0.1, |
| num_heads: int = 8, |
| ): |
| super().__init__() |
| if hidden_dim % num_heads != 0: |
| raise ValueError(f"hidden_dim={hidden_dim} must be divisible by num_heads={num_heads}.") |
|
|
| self.node_proj = nn.Linear(node_in_dim, hidden_dim) |
| self.edge_proj = nn.Linear(edge_in_dim, hidden_dim) |
| self.dropout = nn.Dropout(dropout) |
|
|
| out_channels = hidden_dim // num_heads |
| self.layers = nn.ModuleList([ |
| TransformerConv( |
| hidden_dim, |
| out_channels, |
| heads=num_heads, |
| concat=True, |
| beta=True, |
| dropout=dropout, |
| edge_dim=hidden_dim, |
| ) |
| for _ in range(num_layers) |
| ]) |
| self.attn_norms = nn.ModuleList([nn.LayerNorm(hidden_dim) for _ in range(num_layers)]) |
| self.ff_norms = nn.ModuleList([nn.LayerNorm(hidden_dim) for _ in range(num_layers)]) |
| self.ff_layers = nn.ModuleList([ |
| nn.Sequential( |
| nn.Linear(hidden_dim, hidden_dim * 4), |
| nn.SiLU(), |
| nn.Linear(hidden_dim * 4, hidden_dim), |
| ) |
| for _ in range(num_layers) |
| ]) |
|
|
| def forward(self, data) -> torch.Tensor: |
| x = self.node_proj(data.x) |
| edge_attr = self.edge_proj(data.edge_attr) |
|
|
| for conv, attn_norm, ff_norm, ff in zip( |
| self.layers, |
| self.attn_norms, |
| self.ff_norms, |
| self.ff_layers, |
| ): |
| attn_out = conv(x, data.edge_index, edge_attr=edge_attr) |
| x = attn_norm(x + self.dropout(attn_out)) |
| x = ff_norm(x + self.dropout(ff(x))) |
|
|
| return x |
|
|
