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
|