code/FLARE/flare/models/mol_encoder.py

import torch
import torch.nn as nn
import dgl
from dgllife.model import GCN, GAT, MPNNGNN


class MPNNWrapper(nn.Module):
    """
    Wraps MPNNGNN to expose a GCN-compatible 2-argument call signature:
        forward(g, node_feats)  →  forward(g, node_feats, g.edata['e'])
    This satisfies contrastive.py line 66 which calls .GNN(g, ndata) as dead code.
    """
    def __init__(self, mpnn: MPNNGNN):
        super().__init__()
        self._mpnn = mpnn

    def forward(self, g, node_feats, edge_feats=None):
        if edge_feats is None:
            edge_feats = g.edata.get('e')
            if edge_feats is None:
                raise ValueError("MPNN requires g.edata['e'] (bond features)")
        return self._mpnn(g, node_feats, edge_feats)

    # Forward attribute access to the wrapped MPNN (e.g. .parameters())
    def __getattr__(self, name):
        try:
            return super().__getattr__(name)
        except AttributeError:
            return getattr(self._mpnn, name)


class MolEnc(nn.Module):

    def __init__(self,
                 args,
                 in_dim,):
        super().__init__()

        self.return_emb = False
        self.gnn_type = getattr(args, 'gnn_type', 'gcn')

        if args.model in ('filipContrastive', 'crossAttenContrastive', 'filipGlobalContrastive'):
            self.return_emb = True

        dropout = [args.gnn_dropout for _ in range(len(args.gnn_channels))]
        batchnorm = [True for _ in range(len(args.gnn_channels))]
        out_dim = args.gnn_channels[len(args.gnn_channels) - 1]

        if self.gnn_type == 'mpnn':
            # MPNNGNN uses edge features (bond type, ring, stereo: 13-dim for 'full' bond_feature)
            edge_in_dim = getattr(args, 'edge_in_dim', 13)
            mpnn_edge_hidden = getattr(args, 'mpnn_edge_hidden', 128)
            mpnn_steps = getattr(args, 'mpnn_steps', 4)
            self.GNN = MPNNWrapper(MPNNGNN(
                node_in_feats=in_dim,
                edge_in_feats=edge_in_dim,
                node_out_feats=out_dim,
                edge_hidden_feats=mpnn_edge_hidden,
                num_step_message_passing=mpnn_steps,
            ))
        else:
            gnn_map = {
                "gcn": GCN(in_dim, args.gnn_channels, batchnorm=batchnorm, dropout=dropout),
            }
            self.GNN = gnn_map[self.gnn_type]

        self.pool = dgl.nn.pytorch.glob.MaxPooling()

        if not self.return_emb:
            self.fc1_graph = nn.Linear(out_dim, args.gnn_hidden_dim * 2)
            self.fc2_graph = nn.Linear(args.gnn_hidden_dim * 2, args.final_embedding_dim)

            self.dropout = nn.Dropout(args.fc_dropout)
            self.relu = nn.ReLU()

    def forward(self, g, fp=None) -> torch.Tensor:
        g1 = g
        f1 = g.ndata['h']

        if self.gnn_type == 'mpnn':
            e1 = g.edata.get('e', None)
            if e1 is None:
                raise ValueError("MPNN requires edge features in g.edata['e'] — ensure bond_feature != 'none'")
            f = self.GNN(g1, f1, e1)
        else:
            f = self.GNN(g1, f1)

        if self.return_emb:
            return f
        h = self.pool(g1, f)
        if fp is not None:
            h = torch.concat((h, fp), dim=-1)
        h1 = self.relu(self.fc1_graph(h))
        h1 = self.dropout(h1)
        h1 = self.fc2_graph(h1)
        h1 = self.dropout(h1)

        return h1