File size: 4,916 Bytes
2de7ca3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""SSI-DDI model + featurizer, reconstructed exactly from the training code
so the uploaded checkpoint loads into it. Used by the Sentinel backend to
predict drug-drug interactions (with substructure attention) for NOVEL SMILES."""
import numpy as np, torch
import torch.nn as nn, torch.nn.functional as F
from torch_geometric.data import Data, Batch
from torch_geometric.nn import GATConv, global_mean_pool
from rdkit import Chem

ATOM_FEATURES = 37

def atom_features(atom):
    return np.array([
        atom.GetAtomicNum(), atom.GetDegree(), atom.GetFormalCharge(),
        int(atom.GetHybridization()), int(atom.GetIsAromatic()),
        atom.GetTotalNumHs(), atom.GetNumRadicalElectrons(), int(atom.IsInRing()),
    ] + [int(atom.IsInRingSize(r)) for r in range(3, 9)] + [0]*23, dtype=np.float32)[:ATOM_FEATURES]

def smiles_to_graph(smiles):
    mol = Chem.MolFromSmiles(smiles)
    if mol is None:
        return None
    node_feats = torch.tensor(np.array([atom_features(a) for a in mol.GetAtoms()]), dtype=torch.float)
    edges = []
    for bond in mol.GetBonds():
        i, j = bond.GetBeginAtomIdx(), bond.GetEndAtomIdx()
        edges += [[i, j], [j, i]]
    edge_index = torch.tensor(edges, dtype=torch.long).t().contiguous() if edges else torch.zeros((2, 0), dtype=torch.long)
    return Data(x=node_feats, edge_index=edge_index)

class DrugEncoder(nn.Module):
    def __init__(self, in_dim, hidden_dim, out_dim, heads=4):
        super().__init__()
        self.gat1 = GATConv(in_dim, hidden_dim, heads=heads, concat=True, dropout=0.2)
        self.gat2 = GATConv(hidden_dim*heads, out_dim, heads=1, concat=False, dropout=0.2)
    def forward(self, x, edge_index, batch):
        x = F.elu(self.gat1(x, edge_index))
        x = F.elu(self.gat2(x, edge_index))
        return x, global_mean_pool(x, batch)

class SubstructureAttention(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.scale = dim ** -0.5
        self.q = nn.Linear(dim, dim); self.k = nn.Linear(dim, dim); self.v = nn.Linear(dim, dim)
    def forward(self, atoms_a, atoms_b, return_attn=False):
        Q, K, V = self.q(atoms_a), self.k(atoms_b), self.v(atoms_b)
        attn = torch.softmax(Q @ K.T * self.scale, dim=-1)
        out = attn @ V
        return (out, attn) if return_attn else out

class SSIDDI(nn.Module):
    def __init__(self, atom_dim=ATOM_FEATURES, hidden=64, out=128):
        super().__init__()
        self.encoder = DrugEncoder(atom_dim, hidden, out)
        self.ssi_ab = SubstructureAttention(out)
        self.ssi_ba = SubstructureAttention(out)
        self.classifier = nn.Sequential(
            nn.Linear(out*4, 256), nn.ReLU(), nn.Dropout(0.3),
            nn.Linear(256, 64), nn.ReLU(),
            nn.Linear(64, 1),
        )
    def forward(self, batch_a, batch_b):
        atoms_a, drug_a = self.encoder(batch_a.x, batch_a.edge_index, batch_a.batch)
        atoms_b, drug_b = self.encoder(batch_b.x, batch_b.edge_index, batch_b.batch)
        feats = []
        for i in range(batch_a.num_graphs):
            aa = atoms_a[batch_a.batch == i]; bb = atoms_b[batch_b.batch == i]
            ab = self.ssi_ab(aa, bb).mean(0); ba = self.ssi_ba(bb, aa).mean(0)
            feats.append(torch.cat([ab, ba], dim=-1))
        ssi = torch.stack(feats)
        combined = torch.cat([drug_a, drug_b, ssi], dim=-1)
        return self.classifier(combined).squeeze(-1)

    @torch.no_grad()
    def attribution(self, smiles_a, smiles_b):
        """Return interaction prob + per-atom attention weights (substructure attribution)."""
        self.eval()
        ga, gb = smiles_to_graph(smiles_a), smiles_to_graph(smiles_b)
        if ga is None or gb is None:
            return None
        ba, bb = Batch.from_data_list([ga]), Batch.from_data_list([gb])
        atoms_a, drug_a = self.encoder(ba.x, ba.edge_index, ba.batch)
        atoms_b, drug_b = self.encoder(bb.x, bb.edge_index, bb.batch)
        ab, attn_ab = self.ssi_ab(atoms_a, atoms_b, return_attn=True)
        ba_, attn_ba = self.ssi_ba(atoms_b, atoms_a, return_attn=True)
        ssi = torch.cat([ab.mean(0), ba_.mean(0)], dim=-1).unsqueeze(0)
        combined = torch.cat([drug_a, drug_b, ssi], dim=-1)
        prob = torch.sigmoid(self.classifier(combined).squeeze(-1)).item()
        # atom importance = how much attention each atom receives, aggregated
        a_importance = attn_ab.mean(0).cpu().numpy()   # attention drug B atoms get from A? -> use column/row means
        return {
            "prob": prob,
            "a_atom_importance": attn_ba.mean(0).cpu().numpy().tolist(),  # A atoms attended by B
            "b_atom_importance": attn_ab.mean(0).cpu().numpy().tolist(),  # B atoms attended by A
        }

def load_ssiddi(ckpt_path, device="cpu"):
    model = SSIDDI().to(device)
    sd = torch.load(ckpt_path, map_location=device)
    model.load_state_dict(sd)
    model.eval()
    return model