File size: 4,155 Bytes
f15a766 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 | from __future__ import annotations
from typing import Literal
import torch
import torch.nn as nn
from torch_geometric.nn import GINEConv, GPSConv
from graphwm.models.graph_encoder_edge_transformer import EdgeTransformerGraphSpatialEncoder
from graphwm.models.graph_encoder_gatv2 import GATv2GraphSpatialEncoder
from graphwm.models.graph_encoder_hybrid import HybridGINETransformerGraphSpatialEncoder
from graphwm.models.graph_encoder_transformer import TransformerGraphSpatialEncoder
class _GINEGPSGraphSpatialEncoder(nn.Module):
"""Per-frame spatial graph encoder using GINE or GPSConv."""
def __init__(
self,
node_in_dim: int,
edge_in_dim: int,
hidden_dim: int = 256,
num_layers: int = 4,
dropout: float = 0.1,
backbone: Literal["gine", "gps"] = "gine",
num_heads: int = 8,
):
super().__init__()
self.backbone = backbone
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)
self.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),
)
if backbone == "gine":
conv = GINEConv(mlp, edge_dim=hidden_dim)
elif backbone == "gps":
conv = GPSConv(
channels=hidden_dim,
conv=GINEConv(mlp, edge_dim=hidden_dim),
heads=num_heads,
attn_type="multihead",
attn_kwargs={"dropout": dropout},
)
else:
raise ValueError(f"Unsupported graph backbone: {backbone}")
self.layers.append(conv)
self.norm = nn.LayerNorm(hidden_dim)
def forward(self, data) -> torch.Tensor:
x = self.node_proj(data.x)
edge_attr = self.edge_proj(data.edge_attr)
for layer in self.layers:
residual = x
if self.backbone == "gps":
x = layer(x, data.edge_index, data.batch, edge_attr=edge_attr)
else:
x = layer(x, data.edge_index, edge_attr=edge_attr)
x = self.norm(x + self.dropout(x) + residual)
return x
class GraphSpatialEncoder(nn.Module):
"""Factory wrapper for per-frame spatial graph encoders."""
SUPPORTED_BACKBONES = (
"gine",
"gps",
"gatv2",
"transformer",
"edge_transformer",
"hybrid_gine_transformer",
)
def __init__(
self,
node_in_dim: int,
edge_in_dim: int,
hidden_dim: int = 256,
num_layers: int = 4,
dropout: float = 0.1,
backbone: str = "gine",
num_heads: int = 8,
):
super().__init__()
if backbone in {"gine", "gps"}:
encoder_cls = _GINEGPSGraphSpatialEncoder
kwargs = {"backbone": backbone}
elif backbone == "gatv2":
encoder_cls = GATv2GraphSpatialEncoder
kwargs = {}
elif backbone == "transformer":
encoder_cls = TransformerGraphSpatialEncoder
kwargs = {}
elif backbone == "edge_transformer":
encoder_cls = EdgeTransformerGraphSpatialEncoder
kwargs = {}
elif backbone == "hybrid_gine_transformer":
encoder_cls = HybridGINETransformerGraphSpatialEncoder
kwargs = {}
else:
raise ValueError(
f"Unsupported graph backbone: {backbone}. "
f"Supported: {', '.join(self.SUPPORTED_BACKBONES)}"
)
self.backbone = backbone
self.encoder = encoder_cls(
node_in_dim=node_in_dim,
edge_in_dim=edge_in_dim,
hidden_dim=hidden_dim,
num_layers=num_layers,
dropout=dropout,
num_heads=num_heads,
**kwargs,
)
def forward(self, data) -> torch.Tensor:
return self.encoder(data)
|