Download atomtoken/__main__.py from Scinetics-ai/all-atom-structure-tokenizer: direct link, hf CLI and curl.
- Browser
- Download file 3.73 kB
-
https://huggingface.co/Scinetics-ai/all-atom-structure-tokenizer/resolve/main/atomtoken/__main__.py
- Command line
-
hf download hf://Scinetics-ai/all-atom-structure-tokenizer/atomtoken/__main__.py
-
curl -L -o __main__.py https://huggingface.co/Scinetics-ai/all-atom-structure-tokenizer/resolve/main/atomtoken/__main__.py
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() | |