"""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()