dmt.py

from torch_geometric.nn.conv import MessagePassing
from torch_geometric.nn import global_mean_pool
from torch_geometric.utils import softmax
import math
from typing import Tuple, Optional
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import Tensor
from torch_geometric.typing import Adj, OptTensor
import numpy as np

def coord2dist(x, edge_index, sqrt=False, pos_unmask=None):
    if x.dim() == 3 and pos_unmask is not None:
        x = x * pos_unmask.unsqueeze(-1) # shape = [B, 3, 3]
        x = x.sum(dim=1) / pos_unmask.sum(dim=1, keepdim=True).clamp(min=1)
    elif x.shape[1] == 9 and x.dim() == 2:
        # coordinates to distance
        x = x.view(-1, 3, 3).mean(dim=1)
    # coordinates to distance
    row, col = edge_index
    coord_diff = x[row] - x[col]
    radial = torch.sum(coord_diff ** 2, 1).unsqueeze(1)
    if sqrt:
        radial = radial.sqrt()
    return radial.detach()


def modulate(x, shift, scale):
    # return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)
    return x * (1 + scale) + shift

class TransLayer(MessagePassing):
    """The version for involving the edge feature. Multiply Msg. Without FFN and norm."""

    _alpha: OptTensor

    def __init__(self, x_channels: int, out_channels: int,
                 heads: int = 1, dropout: float = 0., edge_dim: Optional[int] = None,
                 bias: bool = True, **kwargs):
        kwargs.setdefault('aggr', 'add')
        super(TransLayer, self).__init__(node_dim=0, **kwargs)

        self.x_channels = x_channels
        self.in_channels = in_channels = x_channels
        self.out_channels = out_channels
        self.heads = heads
        self.dropout = dropout
        self.edge_dim = edge_dim

        self.lin_key = nn.Linear(in_channels, heads * out_channels, bias=bias)
        self.lin_query = nn.Linear(in_channels, heads * out_channels, bias=bias)
        self.lin_value = nn.Linear(in_channels, heads * out_channels, bias=bias)

        self.lin_edge0 = nn.Linear(edge_dim, heads * out_channels, bias=False)
        self.lin_edge1 = nn.Linear(edge_dim, heads * out_channels, bias=False)

        self.proj = nn.Linear(heads * out_channels, heads * out_channels, bias=bias)
        self.reset_parameters()

    def reset_parameters(self):
        self.lin_key.reset_parameters()
        self.lin_query.reset_parameters()
        self.lin_value.reset_parameters()
        self.lin_edge0.reset_parameters()
        self.lin_edge1.reset_parameters()
        self.proj.reset_parameters()

    def forward(self, x: OptTensor,
                edge_index: Adj,
                edge_attr: OptTensor = None
                ) -> Tensor:
        """"""

        H, C = self.heads, self.out_channels

        x_feat = x
        query = self.lin_query(x_feat).view(-1, H, C)
        key = self.lin_key(x_feat).view(-1, H, C)
        value = self.lin_value(x_feat).view(-1, H, C)

        # propagate_type: (x: PairTensor, edge_attr: OptTensor)
        out_x = self.propagate(edge_index, query=query, key=key, value=value, edge_attr=edge_attr, size=None)

        out_x = out_x.view(-1, self.heads * self.out_channels)

        out_x = self.proj(out_x)
        return out_x

    def message(self, query_i: Tensor, key_j: Tensor, value_j: Tensor,
                edge_attr: OptTensor,
                index: Tensor, ptr: OptTensor,
                size_i: Optional[int]) -> Tuple[Tensor, Tensor]:

        edge_attn = self.lin_edge0(edge_attr).view(-1, self.heads, self.out_channels)
        edge_attn = torch.tanh(edge_attn)
        alpha = (query_i * key_j * edge_attn).sum(dim=-1) / math.sqrt(self.out_channels)

        alpha = softmax(alpha, index, ptr, size_i)
        alpha = F.dropout(alpha, p=self.dropout, training=self.training)

        # node feature message
        msg = value_j
        msg = msg * torch.tanh(self.lin_edge1(edge_attr).view(-1, self.heads, self.out_channels))
        msg = msg * alpha.view(-1, self.heads, 1)

        return msg

    def __repr__(self):
        return '{}({}, {}, heads={})'.format(self.__class__.__name__,
                                             self.in_channels,
                                             self.out_channels, self.heads)


class TransLayerOptim(MessagePassing):
    """The version for involving the edge feature. Multiply Msg. Without FFN and norm."""

    _alpha: OptTensor

    def __init__(self, x_channels: int, out_channels: int,
                 heads: int = 1, dropout: float = 0., edge_dim: Optional[int] = None,
                 bias: bool = True, **kwargs):
        kwargs.setdefault('aggr', 'add')
        super(TransLayerOptim, self).__init__(node_dim=0, **kwargs)

        self.x_channels = x_channels
        self.in_channels = in_channels = x_channels
        self.out_channels = out_channels
        self.heads = heads
        self.dropout = dropout
        self.edge_dim = edge_dim

        self.lin_qkv = nn.Linear(in_channels, heads * out_channels * 3, bias=bias)

        self.lin_edge = nn.Linear(edge_dim, heads * out_channels * 2, bias=False)

        self.proj = nn.Linear(heads * out_channels, heads * out_channels, bias=bias)
        self.reset_parameters()

    def reset_parameters(self):
        self.lin_qkv.reset_parameters()
        self.lin_edge.reset_parameters()
        self.proj.reset_parameters()

    def forward(self, x: OptTensor,
                edge_index: Adj,
                edge_attr: OptTensor = None
                ) -> Tensor:
        """"""

        H, C = self.heads, self.out_channels
        x_feat = x
        qkv = self.lin_qkv(x_feat).view(-1, H, 3, C)
        query, key, value = qkv.unbind(dim=2)

        # propagate_type: (x: PairTensor, edge_attr: OptTensor)
        out_x = self.propagate(edge_index, query=query, key=key, value=value, edge_attr=edge_attr, size=None)

        out_x = out_x.view(-1, self.heads * self.out_channels)

        out_x = self.proj(out_x)
        return out_x

    def message(self, query_i: Tensor, key_j: Tensor, value_j: Tensor,
                edge_attr: OptTensor,
                index: Tensor, ptr: OptTensor,
                size_i: Optional[int]) -> Tuple[Tensor, Tensor]:

        edge_key, edge_value = torch.tanh(self.lin_edge(edge_attr)).view(-1, self.heads, 2, self.out_channels).unbind(dim=2)
        
        alpha = (query_i * key_j * edge_key).sum(dim=-1) / math.sqrt(self.out_channels)

        alpha = softmax(alpha, index, ptr, size_i)
        alpha = F.dropout(alpha, p=self.dropout, training=self.training)

        # node feature message
        msg = value_j * edge_value * alpha.view(-1, self.heads, 1)
        return msg

    def __repr__(self):
        return '{}({}, {}, heads={})'.format(self.__class__.__name__,
                                             self.in_channels,
                                             self.out_channels, self.heads)


class TransLayerOptimV2(MessagePassing):
    """The version for involving the edge feature. Multiply Msg. Without FFN and norm."""

    _alpha: OptTensor

    def __init__(self, x_channels: int, out_channels: int,
                 heads: int = 1, dropout: float = 0., edge_dim: Optional[int] = None,
                 bias: bool = True, **kwargs):
        kwargs.setdefault('aggr', 'add')
        super(TransLayerOptimV2, self).__init__(node_dim=0, **kwargs)

        self.x_channels = x_channels
        self.in_channels = in_channels = x_channels
        self.out_channels = out_channels
        self.heads = heads
        self.dropout = dropout
        self.edge_dim = edge_dim

        self.lin_q = nn.Linear(in_channels, heads * out_channels, bias=bias)
        self.edge_mlp = nn.Sequential(
            nn.Linear(in_channels + edge_dim, in_channels, bias=bias),
            nn.GELU(),
        )

        self.lin_kv = nn.Linear(in_channels, heads * out_channels * 2, bias=bias)

        self.proj = nn.Linear(heads * out_channels, heads * out_channels, bias=bias)
        self.reset_parameters()

    def reset_parameters(self):
        self.lin_q.reset_parameters()
        self.lin_kv.reset_parameters()
        # self.edge_mlp.reset_parameters()
        self.proj.reset_parameters()
    
    
    def forward(self, x: OptTensor,
                edge_index: Adj,
                edge_attr: OptTensor = None
                ) -> Tensor:
        """"""

        H, C = self.heads, self.out_channels
        x_feat = x
        query = self.lin_q(x_feat).view(-1, H, C)

        # propagate_type: (x: PairTensor, edge_attr: OptTensor)
        out_x = self.propagate(edge_index, query=query, x_feat=x_feat, edge_attr=edge_attr)

        out_x = out_x.view(-1, self.heads * self.out_channels)

        out_x = self.proj(out_x)
        return out_x

    def message(self, query_i: Tensor, x_feat_j: Tensor,
                edge_attr: OptTensor,
                index: Tensor, ptr: OptTensor,
                size_i: Optional[int]) -> Tuple[Tensor, Tensor]:

        edge_feat_ij = self.edge_mlp(torch.cat([x_feat_j, edge_attr], dim=-1)) # shape [N * N, in_channels]
        edge_key_ij, edge_value_ij = self.lin_kv(edge_feat_ij).view(-1, self.heads, 2, self.out_channels).unbind(dim=2) # shape [N * N, heads, out_channels]

        alpha_ij = (query_i * edge_key_ij).sum(dim=-1) / math.sqrt(self.out_channels) # shape [N * N, heads]

        alpha_ij = softmax(alpha_ij, index, ptr, size_i) 
        alpha_ij = F.dropout(alpha_ij, p=self.dropout, training=self.training)

        # node feature message
        msg = edge_value_ij * alpha_ij.view(-1, self.heads, 1) # shape [N * N, heads, out_channels]
        return msg

    def __repr__(self):
        return '{}({}, {}, heads={})'.format(self.__class__.__name__,
                                             self.in_channels,
                                             self.out_channels, self.heads)
    

class TransLayerOptimV3(MessagePassing):
    """The version for involving the edge feature. Multiply Msg. Without FFN and norm."""

    _alpha: OptTensor

    def __init__(self, x_channels: int, out_channels: int,
                 heads: int = 1, dropout: float = 0., edge_dim: Optional[int] = None,
                 bias: bool = True, **kwargs):
        kwargs.setdefault('aggr', 'add')
        super(TransLayerOptimV3, self).__init__(node_dim=0, **kwargs)

        self.x_channels = x_channels
        self.in_channels = in_channels = x_channels
        self.out_channels = out_channels
        self.heads = heads
        self.dropout = dropout
        self.edge_dim = edge_dim

        self.lin_q = nn.Linear(in_channels + edge_dim, heads * out_channels, bias=bias)
        self.lin_kv = nn.Linear(in_channels + edge_dim, heads * out_channels * 2, bias=bias)
        self.proj = nn.Linear(heads * out_channels, heads * out_channels, bias=bias)
        self.reset_parameters()

    def reset_parameters(self):
        self.lin_q.reset_parameters()
        self.lin_kv.reset_parameters()
        self.proj.reset_parameters()
    
    
    def forward(self, x: OptTensor,
                edge_index: Adj,
                edge_attr: OptTensor = None,
                edge_mask: OptTensor = None
                ) -> Tensor:
        """"""
        x_feat = x

        # propagate_type: (x: PairTensor, edge_attr: OptTensor)
        out_x = self.propagate(edge_index, x_feat=x_feat, edge_attr=edge_attr)

        out_x = out_x.view(-1, self.heads * self.out_channels)

        out_x = self.proj(out_x)
        return out_x

    def message(self, x_feat_i: Tensor, x_feat_j: Tensor,
                edge_attr: OptTensor,
                index: Tensor, ptr: OptTensor,
                size_i: Optional[int]) -> Tuple[Tensor, Tensor]:
        query_ij = self.lin_q(torch.cat([x_feat_i, edge_attr], dim=-1)).view(-1, self.heads, self.out_channels)
        edge_key_ij, edge_value_ij = self.lin_kv(torch.cat([x_feat_j, edge_attr], dim=-1)).view(-1, self.heads, 2, self.out_channels).unbind(dim=2) # shape [N * N, heads, out_channels]

        alpha_ij = (query_ij * edge_key_ij).sum(dim=-1) / math.sqrt(self.out_channels) # shape [N * N, heads]
        alpha_ij = softmax(alpha_ij, index, ptr, size_i) 
        alpha_ij = F.dropout(alpha_ij, p=self.dropout, training=self.training)

        # node feature message
        msg = edge_value_ij * alpha_ij.view(-1, self.heads, 1) # shape [N * N, heads, out_channels]
        return msg

    def __repr__(self):
        return '{}({}, {}, heads={})'.format(self.__class__.__name__,
                                             self.in_channels,
                                             self.out_channels, self.heads)
    
class TransLayerOptimV3Mask(MessagePassing):
    """The version for involving the edge feature. Multiply Msg. Without FFN and norm."""

    _alpha: OptTensor

    def __init__(self, x_channels: int, out_channels: int,
                 heads: int = 1, dropout: float = 0., edge_dim: Optional[int] = None,
                 bias: bool = True, **kwargs):
        kwargs.setdefault('aggr', 'add')
        super(TransLayerOptimV3Mask, self).__init__(node_dim=0, **kwargs)

        self.x_channels = x_channels
        self.in_channels = in_channels = x_channels
        self.out_channels = out_channels
        self.heads = heads
        self.dropout = dropout
        self.edge_dim = edge_dim

        self.lin_q = nn.Linear(in_channels + edge_dim, heads * out_channels, bias=bias)
        self.lin_kv = nn.Linear(in_channels + edge_dim, heads * out_channels * 2, bias=bias)
        self.proj = nn.Linear(heads * out_channels, heads * out_channels, bias=bias)
        self.reset_parameters()

    def reset_parameters(self):
        self.lin_q.reset_parameters()
        self.lin_kv.reset_parameters()
        self.proj.reset_parameters()
    
    
    def forward(self, x: OptTensor,
                edge_index: Adj,
                edge_attr: OptTensor = None,
                edge_mask: OptTensor = None
                ) -> Tensor:
        """"""
        x_feat = x

        # propagate_type: (x: PairTensor, edge_attr: OptTensor)
        out_x = self.propagate(edge_index, x_feat=x_feat, edge_attr=edge_attr, edge_mask=edge_mask)

        out_x = out_x.view(-1, self.heads * self.out_channels)

        out_x = self.proj(out_x)
        return out_x

    def message(self, x_feat_i: Tensor, x_feat_j: Tensor,
                edge_attr: OptTensor, edge_mask: OptTensor,
                index: Tensor, ptr: OptTensor,
                size_i: Optional[int]) -> Tuple[Tensor, Tensor]:
        query_ij = self.lin_q(torch.cat([x_feat_i, edge_attr], dim=-1)).view(-1, self.heads, self.out_channels)
        edge_key_ij, edge_value_ij = self.lin_kv(torch.cat([x_feat_j, edge_attr], dim=-1)).view(-1, self.heads, 2, self.out_channels).unbind(dim=2) # shape [N * N, heads, out_channels]

        alpha_ij = (query_ij * edge_key_ij).sum(dim=-1) / math.sqrt(self.out_channels) # shape [N * N, heads]
        min_dtype = torch.finfo(alpha_ij.dtype).min
        alpha_ij = alpha_ij + min_dtype * edge_mask.view(-1, 1)
        
        alpha_ij = softmax(alpha_ij, index, ptr, size_i) 
        alpha_ij = F.dropout(alpha_ij, p=self.dropout, training=self.training)

        # node feature message
        msg = edge_value_ij * alpha_ij.view(-1, self.heads, 1) # shape [N * N, heads, out_channels]
        return msg

    def __repr__(self):
        return '{}({}, {}, heads={})'.format(self.__class__.__name__,
                                             self.in_channels,
                                             self.out_channels, self.heads)


class TransLayerOptimV4(MessagePassing):
    """The version for involving the edge feature. Multiply Msg. Without FFN and norm."""

    _alpha: OptTensor

    def __init__(self, x_channels: int, out_channels: int,
                 heads: int = 1, dropout: float = 0., edge_dim: Optional[int] = None,
                 bias: bool = True, **kwargs):
        kwargs.setdefault('aggr', 'add')
        super(TransLayerOptimV4, self).__init__(node_dim=0, **kwargs)

        self.x_channels = x_channels
        self.in_channels = in_channels = x_channels
        self.out_channels = out_channels
        self.heads = heads
        self.dropout = dropout
        self.edge_dim = edge_dim

        self.lin_qkv = nn.Linear(in_channels, heads * out_channels * 3, bias=bias)
        self.lin_qkv_e = nn.Linear(edge_dim, heads * out_channels * 3, bias=False)
        self.proj = nn.Linear(heads * out_channels, heads * out_channels, bias=bias)
        self.reset_parameters()

    def reset_parameters(self):
        self.lin_qkv.reset_parameters()
        self.lin_qkv_e.reset_parameters()
        self.proj.reset_parameters()
    
    
    def forward(self, x: OptTensor,
                edge_index: Adj,
                edge_attr: OptTensor = None
                ) -> Tensor:
        """"""
        x_feat = x

        query, key, value = self.lin_qkv(x_feat).view(-1, self.heads, 3, self.out_channels).unbind(dim=2)
        # propagate_type: (x: PairTensor, edge_attr: OptTensor)
        out_x = self.propagate(edge_index, query=query, key=key, value=value, edge_attr=edge_attr)

        out_x = out_x.view(-1, self.heads * self.out_channels)

        out_x = self.proj(out_x)
        return out_x

    def message(self, query_i: Tensor, key_j: Tensor, value_j: Tensor,
                edge_attr: OptTensor,
                index: Tensor, ptr: OptTensor,
                size_i: Optional[int]) -> Tuple[Tensor, Tensor]:

        edge_query_ij, edge_key_ij, edge_value_ij = self.lin_qkv_e(edge_attr).view(-1, self.heads, 3, self.out_channels).unbind(dim=2)
        
        query_ij = query_i + edge_query_ij
        key_ij = key_j + edge_key_ij
        value_ij = value_j + edge_value_ij

        alpha_ij = (query_ij * key_ij).sum(dim=-1) / math.sqrt(self.out_channels) # shape [N * N, heads]
        alpha_ij = softmax(alpha_ij, index, ptr, size_i) 
        alpha_ij = F.dropout(alpha_ij, p=self.dropout, training=self.training)

        # node feature message
        msg = value_ij * alpha_ij.view(-1, self.heads, 1) # shape [N * N, heads, out_channels]
        return msg

    def __repr__(self):
        return '{}({}, {}, heads={})'.format(self.__class__.__name__,
                                             self.in_channels,
                                             self.out_channels, self.heads)
    
@torch.jit.script
def gaussian(x, mean, std):
    pi = 3.14159
    a = (2 * pi) ** 0.5
    return torch.exp(-0.5 * (((x - mean) / std) ** 2)) / (a * std)


class GaussianLayer(nn.Module):
    """Gaussian basis function layer for 3D distance features"""
    def __init__(self, K, dist_mask_type=False, *args, **kwargs):
        super().__init__()
        self.K = K - 1
        self.means = nn.Embedding(1, self.K)
        self.stds = nn.Embedding(1, self.K)
        nn.init.uniform_(self.means.weight, 0, 3)
        nn.init.uniform_(self.stds.weight, 0, 3)

        self.dist_mask_type = dist_mask_type
        if self.dist_mask_type == 'replace':
            self.mask_token = nn.Parameter(torch.zeros(1, K))
            # self.init_mask_token()
        elif self.dist_mask_type == 'add':
            self.mask_token = nn.Parameter(torch.zeros(2, K))
            nn.init.xavier_normal_(self.mask_token)
        elif self.dist_mask_type == 'none':
            pass
        else:
            raise ValueError(f'Unknown mask_token {dist_mask_type}')

    def forward(self, x, x_mask=None, *args, **kwargs):
        mean = self.means.weight.float().view(-1)
        std = self.stds.weight.float().view(-1).abs() + 1e-5
        out = torch.cat([x, gaussian(x, mean, std).type_as(self.means.weight)], dim=-1)
        
        if self.dist_mask_type == 'replace':
            out[x_mask] = self.mask_token
        elif self.dist_mask_type == 'add':
            out = out + self.mask_token[x_mask.long()]
        elif self.dist_mask_type == 'none':
            pass
        else:
            assert False
        return out


class DMTBlock(nn.Module):
    """Equivariant block based on graph relational transformer layer, without extra heads."""

    def __init__(self, node_dim, edge_dim, num_heads, 
                mlp_ratio=4, act=nn.GELU, dropout=0.0, pair_update=True, trans_ver='v3'):
        super().__init__()
        self.dropout = dropout
        self.act = act()
        self.pair_update = pair_update
        
        if not self.pair_update:
            self.edge_emb = nn.Sequential(
                nn.Linear(edge_dim, edge_dim * 2), 
                nn.GELU(), 
                nn.Linear(edge_dim * 2, edge_dim),
                nn.LayerNorm(edge_dim),
            )

        if trans_ver == 'v2':
            # message passing layer
            self.attn_mpnn = TransLayerOptimV2(node_dim, node_dim // num_heads, num_heads, edge_dim=edge_dim, dropout=dropout)
        elif trans_ver == 'v3':
            # message passing layer
            self.attn_mpnn = TransLayerOptimV3(node_dim, node_dim // num_heads, num_heads, edge_dim=edge_dim, dropout=dropout)
        elif trans_ver == 'v4':
            # message passing layer
            self.attn_mpnn = TransLayerOptimV4(node_dim, node_dim // num_heads, num_heads, edge_dim=edge_dim, dropout=dropout)
        else:
            # message passing layer
            self.attn_mpnn = TransLayerOptim(node_dim, node_dim // num_heads, num_heads, edge_dim=edge_dim, dropout=dropout)

        # Feed forward block -> node.
        self.ff_linear1 = nn.Linear(node_dim, node_dim * mlp_ratio)
        self.ff_linear2 = nn.Linear(node_dim * mlp_ratio, node_dim)
        
        if pair_update:
            self.node2edge_lin = nn.Linear(node_dim * 2 + edge_dim, edge_dim)
            # Feed forward block -> edge.
            self.ff_linear3 = nn.Linear(edge_dim, edge_dim * mlp_ratio)
            self.ff_linear4 = nn.Linear(edge_dim * mlp_ratio, edge_dim)
        
        # equivariant edge update layer
        self.norm1_node = nn.LayerNorm(node_dim, elementwise_affine=True, eps=1e-6)
        self.norm2_node = nn.LayerNorm(node_dim, elementwise_affine=True, eps=1e-6)
        if self.pair_update:
            self.norm1_edge = nn.LayerNorm(edge_dim, elementwise_affine=True, eps=1e-6)
            self.norm2_edge = nn.LayerNorm(edge_dim, elementwise_affine=True, eps=1e-6)

    def _ff_block_node(self, x):
        x = F.dropout(self.act(self.ff_linear1(x)), p=self.dropout, training=self.training)
        return F.dropout(self.ff_linear2(x), p=self.dropout, training=self.training)

    def _ff_block_edge(self, x):
        x = F.dropout(self.act(self.ff_linear3(x)), p=self.dropout, training=self.training)
        return F.dropout(self.ff_linear4(x), p=self.dropout, training=self.training)

    def forward(self, h, edge_attr, edge_index):
        """
        A more optimized version of forward_old using torch.compile
        Params:
            h: [B*N, hid_dim]
            edge_attr: [N_edge, edge_hid_dim]
            edge_index: [2, N_edge]
        """
        h_in_node = h
        h_in_edge = edge_attr

        ## prepare node features
        h = self.norm1_node(h)

        ## prepare edge features
        if self.pair_update:
            edge_attr = self.norm1_edge(edge_attr)
        else:
            edge_attr = self.edge_emb(edge_attr)

        # apply transformer-based message passing, update node features and edge features (FFN + norm)
        h_node = self.attn_mpnn(h, edge_index, edge_attr)

        ## update node features
        h_out = self.node_update(h_in_node, h_node)
        
        ## update edge features
        if self.pair_update:
            # h_edge = h_node[edge_index[0]] + h_node[edge_index[1]]
            h_edge = h_node[edge_index.transpose(0, 1)].flatten(1, 2) # shape [N_edge, 2 * edge_hid_dim]
            h_edge = torch.cat([h_edge, h_in_edge], dim=-1)
            h_edge_out = self.edge_update(h_in_edge, h_edge)
        else:
            h_edge_out = h_in_edge
        return h_out, h_edge_out

    # @torch.compile(dynamic=True, disable=disable_compile)
    def node_update(self, h_in_node, h_node):
        h_node = h_in_node + h_node
        _h_node = self.norm2_node(h_node)
        h_out = h_node + self._ff_block_node(_h_node)
        return h_out
    
    # @torch.compile(dynamic=True, disable=disable_compile)
    def edge_update(self, h_in_edge, h_edge):
        h_edge = self.node2edge_lin(h_edge)
        h_edge = h_in_edge + h_edge
        _h_edge = self.norm2_edge(h_edge)
        h_edge_out = h_edge + self._ff_block_edge(_h_edge)
        return h_edge_out


class PositionalEncoding(nn.Module):
    def __init__(self, d_hid, n_position=3000):
        super(PositionalEncoding, self).__init__()

        # Not a parameter
        self.register_buffer('pos_table', self._get_sinusoid_encoding_table(n_position, d_hid))

    def _get_sinusoid_encoding_table(self, n_position, d_hid):
        ''' Sinusoid position encoding table '''
        # TODO: make it with torch instead of numpy

        def get_position_angle_vec(position):
            return [position / np.power(10000, 2 * (hid_j // 2) / d_hid) for hid_j in range(d_hid)]

        sinusoid_table = np.array([get_position_angle_vec(pos_i) for pos_i in range(n_position)]) # shape = [n_position, d_hid]
        sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2])  # dim 2i
        sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2])  # dim 2i+1

        return torch.FloatTensor(sinusoid_table) # shape = [n_position, d_hid]

    def forward(self, seq_pos):
        '''
        seq_pos: [\sum_i N_i, ]
        '''
        return self.pos_table[seq_pos].clone().detach() # shape = [\sum_i N_i, d_hid]

class NodeEmbed(nn.Module):
    def __init__(self, in_node_features, hidden_size, pos_dim=72, mlp_ratio=4, pos_mask_type='none', llm_embed=False, use_protenix_emb=True, protenix_hidden_dim=384):
        super().__init__()
        self.x_linear = nn.Linear(in_node_features, hidden_size * mlp_ratio, bias=False)
        self.pos_linear = nn.Linear(pos_dim, hidden_size * mlp_ratio, bias=True)
        self.seq_pos_emb = PositionalEncoding(hidden_size)
        self.seq_pos_linear = nn.Linear(hidden_size, hidden_size * mlp_ratio, bias=False)
        self.llm_embed = llm_embed
        self.use_llm_mlp = False
        self.use_protenix_emb = use_protenix_emb

        if llm_embed:
            if self.use_llm_mlp:
                self.llm_mlp = nn.Sequential(
                    nn.Linear(hidden_size, hidden_size * mlp_ratio),
                    nn.GELU(),
                    nn.Linear(hidden_size * mlp_ratio, hidden_size)
                )
            else:
                self.llm_mlp = nn.Linear(hidden_size, hidden_size * mlp_ratio, bias=False)

        if use_protenix_emb:
            self.protenix_mlp = nn.Linear(protenix_hidden_dim, hidden_size * mlp_ratio, bias=False)

        self.mlp = nn.Sequential(
                nn.GELU(),
                nn.Linear(hidden_size * mlp_ratio, hidden_size)
            )

        self.pos_mask_type = pos_mask_type
        if pos_mask_type == 'replace':
            self.mask_token = nn.Parameter(torch.zeros(1, hidden_size * mlp_ratio))
            nn.init.normal_(self.mask_token, std=.02)
        elif pos_mask_type == 'add':
            self.mask_token = nn.Parameter(torch.zeros(2, hidden_size * mlp_ratio))
            nn.init.xavier_normal_(self.mask_token)
        elif pos_mask_type == 'none':
            pass
        else:
            raise ValueError(f'Unknown pos_mask_type {pos_mask_type}')

    def forward(self, x, pos, seq_pos, pos_mask=None, llm_embed=None, protenix_emb=None):
        if pos.dim() == 3:
            pos = pos.flatten(1,2)
        x = self.x_linear(x)
        pos = self.pos_linear(pos)
        seq_pos = self.seq_pos_linear(self.seq_pos_emb(seq_pos))
        
        if self.pos_mask_type == 'replace':
            pos[pos_mask] = self.mask_token.to(pos.dtype)
        elif self.pos_mask_type == 'add':
            pos = pos + self.mask_token[pos_mask.long()]
        elif self.pos_mask_type == 'none':
            pass
        else:
            assert False
        
        if self.llm_embed:
            if self.use_llm_mlp:
                return self.mlp(x + pos + seq_pos) + self.llm_mlp(llm_embed)
            else:
                return self.mlp(x + pos + seq_pos + self.llm_mlp(llm_embed))
            
        if self.use_protenix_emb:
            return self.mlp(x + pos + seq_pos + self.protenix_mlp(protenix_emb))
        
        return self.mlp(x + pos + seq_pos)
    
class NodeEmbed_with_struc(nn.Module):
    def __init__(self, in_node_features, hidden_size, pos_dim=3, mlp_ratio=4, pos_mask_type='none', llm_embed=False, struc_emb_dim=20):
        super().__init__()
        self.x_linear = nn.Linear(in_node_features, hidden_size * mlp_ratio, bias=False)
        # self.pos_linear = nn.Linear(pos_dim+20, hidden_size * mlp_ratio, bias=True)
        self.pos_linear = nn.Linear(pos_dim, hidden_size * mlp_ratio, bias=True)# add struc_emb [0414 by TIANRUI]
        self.struc_linear = nn.Linear(struc_emb_dim*24, hidden_size * mlp_ratio, bias=False)# add struc_emb [0414 by TIANRUI]
        self.seq_pos_emb = PositionalEncoding(hidden_size)
        self.seq_pos_linear = nn.Linear(hidden_size, hidden_size * mlp_ratio, bias=False)
        self.llm_embed = llm_embed
        self.use_llm_mlp = False
        if llm_embed:
            if self.use_llm_mlp:
                self.llm_mlp = nn.Sequential(
                    nn.Linear(hidden_size, hidden_size * mlp_ratio),
                    nn.GELU(),
                    nn.Linear(hidden_size * mlp_ratio, hidden_size)
                )
            else:
                self.llm_mlp = nn.Linear(hidden_size, hidden_size * mlp_ratio, bias=False)
        self.mlp = nn.Sequential(
                nn.GELU(),
                nn.Linear(hidden_size * mlp_ratio, hidden_size)
            )

        self.pos_mask_type = pos_mask_type
        if pos_mask_type == 'replace':
            self.mask_token = nn.Parameter(torch.zeros(1, hidden_size * mlp_ratio))
            nn.init.normal_(self.mask_token, std=.02)
        elif pos_mask_type == 'add':
            self.mask_token = nn.Parameter(torch.zeros(2, hidden_size * mlp_ratio))
            nn.init.xavier_normal_(self.mask_token)
        elif pos_mask_type == 'none':
            pass
        else:
            raise ValueError(f'Unknown pos_mask_type {pos_mask_type}')

    def forward(self, x, struc_emb, pos, seq_pos, pos_mask=None, llm_embed=None):
        if pos.dim() == 3:
            pos = pos.flatten(1,2)
            struc_emb = struc_emb.flatten(1,2)
        x = self.x_linear(x)
        pos = self.pos_linear(pos)
        # pos = self.pos_linear(pos).sum(dim=1)
        struc_emb = self.struc_linear(struc_emb)
        pos = pos + struc_emb

        seq_pos = self.seq_pos_linear(self.seq_pos_emb(seq_pos))
        
        if self.pos_mask_type == 'replace':
            pos[pos_mask] = self.mask_token.to(pos.dtype)
        elif self.pos_mask_type == 'add':
            pos = pos + self.mask_token[pos_mask.long()]
        elif self.pos_mask_type == 'none':
            pass
        else:
            assert False
        
        if self.llm_embed:
            if self.use_llm_mlp:
                return self.mlp(x + pos + seq_pos) + self.llm_mlp(llm_embed)
            else:
                return self.mlp(x + pos + seq_pos + self.llm_mlp(llm_embed))
        return self.mlp(x + pos + seq_pos)
    
class DMT(nn.Module):
    def __init__(self, configs):
        super().__init__()

        self.use_struc_emb = configs.use_struc_emb
        self.disable_dist = configs.disable_dist
        self.new_aa = configs.new_aa
        self.sqrt_dis = configs.sqrt_dis
        
        edge_dim = configs.hidden_dim // configs.e2n_ratio
        
        if configs.use_struc_emb:
            self.node_emb = NodeEmbed_with_struc(configs.in_res_node_features, configs.hidden_dim, configs.pos_dim, configs.mlp_ratio, configs.pos_mask_type, configs.enable_llm)
        else:
            self.node_emb = NodeEmbed(configs.in_res_node_features, configs.hidden_dim, configs.pos_dim, configs.mlp_ratio, configs.pos_mask_type, configs.enable_llm, configs.use_protenix_emb)
        
        if not configs.disable_dist:
            self.dist_mask_type = configs.dist_mask_type
            # distance GBF embedding
            self.dist_gbf = GaussianLayer(edge_dim, configs.dist_mask_type)
            in_edge_dim = configs.in_res_edge_features + edge_dim
        else:
            in_edge_dim = configs.in_res_edge_features
            
        self.edge_emb = nn.Sequential(
            nn.Linear(in_edge_dim, 2 * edge_dim),
            nn.GELU(),
            nn.Linear(2 * edge_dim, edge_dim),
        )

        self.blocks = nn.ModuleList()
        for _ in range(configs.n_blocks):
            self.blocks.append(DMTBlock(configs.hidden_dim, edge_dim,
                                configs.n_heads, mlp_ratio=configs.mlp_ratio, act=nn.GELU, dropout=configs.dropout, pair_update=not configs.not_pair_update, trans_ver=configs.trans_ver))

        self.pooling_mlp = nn.Sequential(
            nn.Linear(configs.hidden_dim, configs.hidden_dim * configs.mlp_ratio),
            nn.GELU(),
            nn.Linear(configs.hidden_dim * configs.mlp_ratio, configs.hidden_dim)
        )

        self.pred_layer = nn.Sequential(
            nn.Linear(configs.hidden_dim, configs.hidden_dim * configs.mlp_ratio),
            nn.Tanh(),
            nn.Linear(configs.hidden_dim * configs.mlp_ratio, 72)
        )

    def forward(self, data):

        assert hasattr(data, 'seq_pos')
        seq_pos = data.seq_pos

        # obtain node and edge feature
        llm_embed = data.get('llm_embed', None)

        if self.use_struc_emb:
            # add struc_emb [0403 by TIANRUI]
            # struc_input = torch.cat([data.pos, data.struc_emb], dim=-1)
            node_h = self.node_emb(data.x, data.struc_emb, data.gt_pos, seq_pos, data['pos_mask'], llm_embed=llm_embed)
        else:
            # node_h = self.node_emb(data.x, data.gt_pos, seq_pos, data['pos_mask'], llm_embed=llm_embed, protenix_emb=data.get('protenix_emb', None))
            node_h = self.node_emb(data.x, data.pos, seq_pos, data['pos_mask'], llm_embed=llm_embed, protenix_emb=data.get('protenix_emb', None))

        # add distance to edge feature
        if not self.disable_dist:
            if self.new_aa:
                # distance = coord2dist(data.gt_pos, data.edge_index, self.sqrt_dis, ~data.pos_mask)
                distance = coord2dist(data.pos, data.edge_index, self.sqrt_dis, ~data.pos_mask)
            else:
                # distance = coord2dist(data.gt_pos, data.edge_index, self.sqrt_dis)
                distance = coord2dist(data.pos, data.edge_index, self.sqrt_dis)
            
            edge_mask = None
            if self.dist_mask_type != 'none':
                edge_mask = data.pos_mask[data.edge_index].any(dim=0)
            dist_emb = self.dist_gbf(distance, edge_mask)
            edge_h = self.edge_emb(torch.cat([data.edge_attr, dist_emb], dim=-1))
        else:
            edge_h = self.edge_emb(data.edge_attr)

        # run the DMT blocks
        for layer in self.blocks:
            node_h, edge_h = layer(node_h, edge_h, data.edge_index)

        pred_noise = self.pred_layer(node_h).reshape(data.pos.shape)

        denoising_loss = ((pred_noise[~data['pos_mask']] - data['noise'][~data['pos_mask']]) ** 2).mean()

        graph_h = global_mean_pool(node_h, data.batch)  # [B, hidden_dim]

        graph_h = self.pooling_mlp(graph_h)
        return graph_h, denoising_loss

# class InfoNCELoss(nn.Module):
#     def __init__(self, temperature=0.05):
#         super().__init__()
#         self.temperature = temperature

#     def forward(self, z1, z2):
#         """
#         z1, z2: (B, D) 两个视图经过 projection head 的表示
#         """
#         B = z1.shape[0]
#         z = torch.cat([z1, z2], dim=0)  # (2B, D)
#         sim = F.cosine_similarity(z.unsqueeze(1), z.unsqueeze(0), dim=-1)  # (2B, 2B)

#         # Positive indices: i-th with (i + B)%2B
#         labels = torch.arange(B, device=z.device)
#         labels = torch.cat([labels + B, labels], dim=0)

#         # Mask: remove self-similarity
#         mask = ~torch.eye(2 * B, dtype=torch.bool, device=z.device)

#         sim = sim / self.temperature
#         sim_exp = torch.exp(sim) * mask  # (2B, 2B), exp(sim) and remove diagonal

#         # Denominator
#         denom = sim_exp.sum(dim=1)  # (2B,)

#         # Numerator: select positive pairs
#         numerator = torch.exp(sim[torch.arange(2 * B), labels])

#         loss = -torch.log(numerator / denom)
#         return loss.mean()