| from __future__ import annotations |
|
|
| import torch |
| import torch.nn as nn |
| from torch_geometric.nn import GINEConv, TransformerConv |
|
|
|
|
| class HybridGINETransformerGraphSpatialEncoder(nn.Module): |
| """Local GINE message passing followed by edge-aware graph attention.""" |
|
|
| 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.local_layers = nn.ModuleList() |
| self.attn_layers = nn.ModuleList() |
| self.local_norms = nn.ModuleList() |
| self.attn_norms = nn.ModuleList() |
| self.ff_norms = nn.ModuleList() |
| self.ff_layers = nn.ModuleList() |
|
|
| for _ in range(num_layers): |
| mlp = nn.Sequential( |
| nn.Linear(hidden_dim, hidden_dim), |
| nn.SiLU(), |
| nn.Linear(hidden_dim, hidden_dim), |
| ) |
| self.local_layers.append(GINEConv(mlp, edge_dim=hidden_dim)) |
| self.attn_layers.append( |
| TransformerConv( |
| hidden_dim, |
| out_channels, |
| heads=num_heads, |
| concat=True, |
| beta=True, |
| dropout=dropout, |
| edge_dim=hidden_dim, |
| ) |
| ) |
| self.local_norms.append(nn.LayerNorm(hidden_dim)) |
| self.attn_norms.append(nn.LayerNorm(hidden_dim)) |
| self.ff_norms.append(nn.LayerNorm(hidden_dim)) |
| self.ff_layers.append( |
| nn.Sequential( |
| nn.Linear(hidden_dim, hidden_dim * 4), |
| nn.SiLU(), |
| nn.Linear(hidden_dim * 4, hidden_dim), |
| ) |
| ) |
|
|
| def forward(self, data) -> torch.Tensor: |
| x = self.node_proj(data.x) |
| edge_attr = self.edge_proj(data.edge_attr) |
|
|
| for local, attn, local_norm, attn_norm, ff_norm, ff in zip( |
| self.local_layers, |
| self.attn_layers, |
| self.local_norms, |
| self.attn_norms, |
| self.ff_norms, |
| self.ff_layers, |
| ): |
| local_out = local(x, data.edge_index, edge_attr=edge_attr) |
| x = local_norm(x + self.dropout(local_out)) |
|
|
| attn_out = attn(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 |
|
|
