Download atomtoken/training.py from Scinetics-ai/all-atom-structure-tokenizer: direct link, hf CLI and curl.
- Browser
- Download file 4.33 kB
-
https://huggingface.co/Scinetics-ai/all-atom-structure-tokenizer/resolve/main/atomtoken/training.py
- Command line
-
hf download hf://Scinetics-ai/all-atom-structure-tokenizer/atomtoken/training.py
-
curl -L -o training.py https://huggingface.co/Scinetics-ai/all-atom-structure-tokenizer/resolve/main/atomtoken/training.py
4.33 kB
| """One-assembly flow matching and auxiliary chemistry objectives.""" | |
| import torch | |
| from torch.nn import functional as F | |
| from .geometry import signed_volumes | |
| def center(x, mask): | |
| return x - x[mask].mean(0) | |
| def aligned_endpoint(x, noise, mask): | |
| clean = center(torch.where(mask[:, None], x, 0.), mask) / 10. | |
| reference_noise = center(noise, mask) | |
| with torch.no_grad(): | |
| left, _, right = torch.linalg.svd(clean[mask].T @ reference_noise[mask]) | |
| parity = torch.linalg.det(left @ right).sign() | |
| left[:, -1] *= parity | |
| rotation = left @ right | |
| return torch.where(mask[:, None], clean @ rotation + noise[mask].mean(0), noise) | |
| def mean_square(residual): | |
| return residual.square().sum() / max(residual.numel(), 1) | |
| def angular_cosine(x, angles): | |
| a, b, c = angles.T | |
| return (F.normalize(x[b]-x[a]) * F.normalize(x[c]-x[a])).sum(-1) | |
| def evaluation_pairs(chem, mask, budget=2048): | |
| """Bound memory for long assemblies while including intra- and inter-molecular pairs.""" | |
| idx = mask.nonzero().flatten() | |
| if len(idx)**2 <= 2*budget: | |
| return torch.combinations(idx, r=2) | |
| pairs = idx[torch.randint(len(idx), (budget*4, 2), device=idx.device)] | |
| pairs = pairs[pairs[:, 0] != pairs[:, 1]] | |
| mol = chem.molecule[chem.unit[pairs]] | |
| cross = mol[:, 0] != mol[:, 1] | |
| intra, inter = pairs[~cross], pairs[cross] | |
| n_inter = min(len(inter), max(budget//2, budget-len(intra))) | |
| return torch.cat((inter[:n_inter], intra[:budget-n_inter])) | |
| def tokenizer_loss(model, chem, xyz, mask, *, weights=None): | |
| """Returns total and component losses. Coordinates and length penalties use angstroms.""" | |
| lambdas = dict(bond=.1, angle=.1, clash=.05, chiral=.1, distance=.05, usage=.001) | |
| if weights: | |
| if set(weights) - lambdas.keys(): | |
| raise ValueError("Unknown auxiliary loss weight.") | |
| lambdas.update(weights) | |
| if model.training: | |
| rotation, triangular = torch.linalg.qr(torch.randn(3, 3, device=xyz.device, dtype=xyz.dtype)) | |
| rotation = rotation * torch.diagonal(triangular).sign() | |
| rotation[:, -1] *= torch.linalg.det(rotation).sign() | |
| xyz = xyz @ rotation | |
| _, code, raw, present = model(chem, xyz, mask) | |
| noise = torch.randn_like(xyz) | |
| noise -= noise.mean(0) | |
| target = aligned_endpoint(xyz, noise, mask) | |
| t = torch.rand((), device=xyz.device, dtype=xyz.dtype) | |
| state = torch.lerp(noise, target, t) | |
| # Give an entirely unobserved unit an ordinary random code for this training example. | |
| # The decoder API only receives chemistry, code vectors, time, and the noisy state. | |
| filler = model.fsq.from_ids(torch.randint(8192, (chem.units,), device=xyz.device)) | |
| velocity = model.decoder(chem, torch.where(present[:, None], code, filler), state, t) | |
| losses = {"flow": ((velocity - (target-noise))[mask]).square().sum(-1).mean()} | |
| pred = (state + (1.-t)*velocity) * 10. | |
| bonds = chem.bonds[mask[chem.bonds].all(1)] | |
| angles = chem.angles[mask[chem.angles].all(1)] | |
| triplets = chem.triplets[mask[chem.triplets].all(1)] | |
| def lengths(x, pairs): | |
| return (x[pairs[:, 0]]-x[pairs[:, 1]]).norm(dim=-1) | |
| losses["bond"] = mean_square(lengths(pred, bonds)-lengths(xyz, bonds)) | |
| losses["angle"] = mean_square(angular_cosine(pred, angles)-angular_cosine(xyz, angles)) | |
| losses["chiral"] = mean_square(signed_volumes(pred, triplets)-signed_volumes(xyz, triplets)) | |
| pairs = evaluation_pairs(chem, mask) | |
| losses["distance"] = mean_square((lengths(pred, pairs)-lengths(xyz, pairs))/10.) | |
| def keys(pairs): | |
| p, q = pairs.sort(dim=-1).values.T | |
| return p*len(xyz)+q | |
| exclusions = torch.cat((chem.bonds, chem.angles[:, 1:])) | |
| distant = pairs[~torch.isin(keys(pairs), keys(exclusions))] | |
| losses["clash"] = mean_square(F.relu(2.-lengths(pred, distant))) | |
| usage = xyz.new_zeros(()) | |
| for i, n in enumerate((8, 8, 8, 4, 4)): | |
| grid = torch.arange(n, device=xyz.device) | |
| p = (-(raw[present, i, None]-grid).square()/.5).softmax(-1).mean(0) | |
| usage = usage + (p*(p*n).clamp_min(1e-8).log()).sum()/5 | |
| losses["usage"] = usage | |
| total = losses["flow"] + lambdas["usage"]*usage | |
| total = total + t.square()*sum(lambdas[k]*losses[k] for k in ("bond","angle","clash","chiral","distance")) | |
| return total, losses | |