Scinetics-ai's picture
Release the all-atom structural tokenizer reference implementation
4c231da verified
Raw History Blame Contribute Delete
3.73 kB
"""Training, encoding, and chemistry-conditioned decoding from explicit JSON records."""
import argparse
from dataclasses import asdict
import json
from pathlib import Path
import torch
from . import Config, StructureTokenizer, load_assembly, tokenizer_loss
def write_json(path, record):
Path(path).write_text(json.dumps(record, indent=2) + "\n", encoding="utf-8")
def main():
parser = argparse.ArgumentParser(prog="python -m atomtoken")
sub = parser.add_subparsers(dest="command", required=True)
train = sub.add_parser("train")
train.add_argument("assemblies", nargs="+")
train.add_argument("--checkpoint", required=True)
train.add_argument("--steps", type=int, default=1)
train.add_argument("--profile", choices=("report", "tiny"), default="report")
train.add_argument("--lr", type=float, default=2e-4)
enc = sub.add_parser("encode")
dec = sub.add_parser("decode")
for part in (enc, dec):
part.add_argument("assembly")
part.add_argument("--checkpoint", required=True)
part.add_argument("--out", required=True)
dec.add_argument("--tokens", required=True)
dec.add_argument("--steps", type=int, default=50)
for part in (train, enc, dec):
part.add_argument("--device", default="cpu")
part.add_argument("--seed", type=int, default=7)
args = parser.parse_args()
if getattr(args, "steps", 1) < 1:
parser.error("--steps must be positive")
torch.manual_seed(args.seed)
device = torch.device(args.device)
if args.command == "train":
cfg = Config.tiny() if args.profile == "tiny" else Config()
model = StructureTokenizer(cfg).to(device)
opt = torch.optim.AdamW(model.parameters(), lr=args.lr)
for step in range(args.steps):
c, x, mask = load_assembly(args.assemblies[step % len(args.assemblies)])
opt.zero_grad(set_to_none=True)
loss, _ = tokenizer_loss(model, c.to(device), x.to(device), mask.to(device))
if not torch.isfinite(loss):
raise RuntimeError("Non-finite training objective")
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1., error_if_nonfinite=True)
opt.step()
print(f"step {step+1} loss {loss.item():.5f}")
torch.save(dict(format_version=1, config=asdict(cfg), state=model.state_dict()), args.checkpoint)
return
ckpt = torch.load(args.checkpoint, map_location="cpu", weights_only=True)
if ckpt.get("format_version") != 1:
parser.error("Unsupported checkpoint format")
model = StructureTokenizer(Config(**ckpt["config"]))
model.load_state_dict(ckpt["state"])
model = model.to(device).eval()
c, x, mask = load_assembly(args.assembly)
c = c.to(device)
if args.command == "encode":
ids = model.encode(c, x.to(device), mask.to(device)).tolist()
write_json(args.out, {"chemistry_sha256": c.identity, "ids": ids})
return
record = json.loads(Path(args.tokens).read_text(encoding="utf-8"))
if record["chemistry_sha256"] != c.identity:
parser.error("IDs belong to a different chemistry record or atom/unit ordering")
ids = torch.tensor(record["ids"], device=device)
if (ids == -1).any():
parser.error("Supply a structural ID for each entirely unobserved unit before decoding")
rng = torch.Generator(device=device).manual_seed(args.seed)
pred = model.decode(c, ids, steps=args.steps, generator=rng)
out = json.loads(Path(args.assembly).read_text(encoding="utf-8"))
for atom, pos in zip(out["atoms"], pred.tolist()):
atom["xyz"] = pos
write_json(args.out, out)
if __name__ == "__main__":
main()