File size: 4,325 Bytes
4c231da
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Relative geometric features. Directed edges are indexed as receiver, sender."""
import torch
from torch import nn
from torch.nn import functional as F

from .chemistry import FEATURE_SIZES


def reduce_sum(values, index, size):
    return values.new_zeros(size, *values.shape[1:]).index_add_(0, index, values)


def radial(distance):
    centers = torch.linspace(0, 16, 16, device=distance.device, dtype=distance.dtype)
    return torch.exp(-((distance[..., None] - centers) / 1.2).square())


def signed_volumes(x, triplets):
    a, b, c, d = triplets.T
    p, q, r = [F.normalize(x[i] - x[a], dim=-1, eps=1e-7) for i in (b, c, d)]
    return (p * torch.linalg.cross(q, r)).sum(-1)


@torch.no_grad()
def neighbors(chem, x, valid, *, within_unit=False, cutoff=12., caps=(32, 16), chunk=128):
    n = len(x)
    bonds = torch.cat((chem.bonds, chem.bonds.flip(1)))
    orders = chem.order.repeat(2)
    bonds_ok = valid[bonds].all(dim=1)
    dst, src = bonds[bonds_ok].T
    bond_dst, bond_src = dst, src
    target, source = [dst], [src]
    relation, order = [torch.zeros_like(dst)], [orders[bonds_ok]]
    atoms = torch.arange(n, device=x.device)
    mol = chem.molecule[chem.unit]
    for rows in atoms.split(chunk):
        distances = torch.cdist(x[rows], x, compute_mode="donot_use_mm_for_euclid_dist")
        allowed = valid[rows, None] & valid[None, :] & (rows[:, None] != atoms)
        local = (bond_dst >= rows[0]) & (bond_dst <= rows[-1])
        allowed[bond_dst[local] - rows[0], bond_src[local]] = False
        if within_unit:
            internal = allowed & (chem.unit[rows, None] == chem.unit)
            i, j = internal.nonzero(as_tuple=True)
            target.append(rows[i]); source.append(j)
            relation.append(torch.ones_like(j)); order.append(torch.zeros_like(j))
            allowed = allowed & ~internal
        same = mol[rows, None] == mol
        for code, selection, cap in ((1, same, caps[0]), (2, ~same, caps[1])):
            eligible = allowed & selection & (distances <= cutoff)
            ds, js = distances.masked_fill(~eligible, torch.inf).topk(min(cap, n), largest=False)
            i, k = ds.isfinite().nonzero(as_tuple=True)
            j = js[i, k]
            target.append(rows[i]); source.append(j)
            relation.append(torch.full_like(j, code)); order.append(torch.zeros_like(j))
    return tuple(torch.cat(parts) for parts in (target, source, relation, order))


class ChemicalEmbedding(nn.Module):
    def __init__(self, width):
        super().__init__()
        self.tables = nn.ModuleList(nn.Embedding(n, width) for n in FEATURE_SIZES)

    def forward(self, features):
        return sum(table(features[:, i]) for i, table in enumerate(self.tables))


class AtomBlock(nn.Module):
    def __init__(self, width, vectors):
        super().__init__()
        self.message = nn.Sequential(nn.Linear(2*width + 3*vectors + 25, width),
                                     nn.SiLU(), nn.Linear(width, width + 2*vectors))
        self.mix = nn.Linear(vectors, vectors, bias=False)
        self.scalar_norm = nn.LayerNorm(width)
        self.vector_gate = nn.Linear(width + vectors, vectors)
        self.width, self.vectors = width, vectors

    def forward(self, h, v, x, edges, chem):
        dst, src, relation, order = edges
        delta = x[src] - x[dst]
        distance = delta.norm(dim=-1)
        direction = F.normalize(delta, dim=-1, eps=1e-7)
        aligned = direction.unsqueeze(1)
        same_chain = (chem.chain[chem.unit[dst]] == chem.chain[chem.unit[src]]).to(x.dtype)
        inputs = torch.cat((h[dst], h[src], (v[dst]*aligned).sum(-1), (v[src]*aligned).sum(-1),
                            (v[dst]*v[src]).sum(-1), radial(distance),
                            F.one_hot(relation, 3), F.one_hot(order, 5), same_chain[:, None]), -1)
        scalar, g_r, g_v = self.message(inputs).split((self.width, self.vectors, self.vectors), -1)
        mixed = self.mix(v[src].transpose(1, 2)).transpose(1, 2)
        vector = g_r[..., None] * aligned + g_v[..., None] * mixed
        h = self.scalar_norm(h + reduce_sum(scalar, dst, len(h)))
        v = v + reduce_sum(vector, dst, len(v))
        norm = v.norm(dim=-1)
        v = v / (1. + norm[..., None]) * self.vector_gate(torch.cat((h, norm), -1)).sigmoid()[..., None]
        return h, v