Add files using upload-large-folder tool

checkpoints/aizynthfinder/uspto_model_onnx/SHA256SUMS

@@ -2,10 +2,10 @@
 ad29aa32bdfcbe37065045546493806cf04899c55386c438905d83fb14bb6320  aux/uspto_filter_model.onnx
 a4f1945e90cfa195538320833d68aed38f14e2fcc2f8afb5d958bc920edcafbe  aux/uspto_templates.csv.gz
 a10255a6abd89a35d2ea48a842839f403b4b1586805c3010c0d076e0ae23754d  benchmarks/default_test.jsonl
-bacb79ab0ba9d53c331479fe07e003096421eadc03a0a8cc92182b04ab482964  benchmarks/metadata.json
+5c272a6819a4315094e57ad2d63712133a202c778a03fd7c3597e1b459b44224  benchmarks/metadata.json
 87d7e0013f97da27e4fd878b0598466ac07202fe131ac0f7dbdd2b423482751f  benchmarks/native/ref_routes_reaction_hashes.txt
 872533b44788754af3aa19918a04c2a508d30249d2c93eb480078cb638ad3389  benchmarks/native/selected_reactions.csv
-7a00b895410f59d44d2008591ebc15e17c48f582f549686189822be8b8e70814  manifest.json
+3a4cf47b5bc0f374bc7cf3851fa2ef3a5ea8440d52eb9a72e7127f9f754717b8  manifest.json
 bd0a3cb74cd7068de474c8fb789a00a66bc42c75636d66510ccac585ebe928f8  model.onnx
-2a49b5d0439f3bcbc1382603a2bb891b60adae687aa05ad655df8f7e44dff4aa  provenance.json
+a201615c60a1fc9ddab93b85d54101d1068a344e42b448a8f2c8925fc3b335f9  provenance.json
 332fcbbe37447c13381f5cf58baa2431a2dca96e66ef3d1e8562624b916b7a67  wrapper_config.json

checkpoints/aizynthfinder/uspto_model_onnx/benchmarks/metadata.json

@@ -10,7 +10,7 @@
       "notes": [
         "This is the PaRoutes selected_reactions.csv source table used to reconstruct the held-out reference-route reaction subset."
       ],
-      "origin": "copied_from_local_zenodo_record",
+      "origin": "copied_from_local_public_record",
       "relative_path": "benchmarks/native/selected_reactions.csv",
       "source_url": "https://zenodo.org/records/7341155/files/selected_reactions.csv?download=1"
     },
@@ -18,7 +18,7 @@
       "notes": [
         "This hash list identifies the exact AiZynthTrain/PaRoutes reference reactions held out for testing."
       ],
-      "origin": "copied_from_local_zenodo_record",
+      "origin": "copied_from_local_public_record",
       "relative_path": "benchmarks/native/ref_routes_reaction_hashes.txt",
       "source_url": "https://zenodo.org/records/7341155/files/ref_routes_reaction_hashes.txt?download=1"
     }
@@ -28,7 +28,7 @@
     "The benchmark rows are reconstructed from PaRoutes selected_reactions.csv and ref_routes_reaction_hashes.txt so they match the held-out reference-route reactions used as the AiZynthTrain test set."
   ],
   "num_examples": 56657,
-  "source_reference_hashes_path": "datasets/zenodo-7341155/ref_routes_reaction_hashes.txt",
-  "source_selected_reactions_path": "datasets/zenodo-7341155/selected_reactions.csv",
+  "source_reference_hashes_path": "datasets/paroutes_public_data/ref_routes_reaction_hashes.txt",
+  "source_selected_reactions_path": "datasets/paroutes_public_data/selected_reactions.csv",
   "split": "test"
 }

checkpoints/aizynthfinder/uspto_model_onnx/manifest.json

@@ -35,7 +35,7 @@
     {
       "canonical_split_family": "aizynthtrain_uspto_selected_reactions_paroutes_reference_holdout",
       "dataset_ref": "aizynthtrain_uspto_selected_reactions_with_paroutes_holdout",
-      "path": "zenodo-11430881/uspto_model.onnx",
+      "path": "aizynthfinder_public_data/uspto_model.onnx",
       "split_names": [
         "train",
         "val",
@@ -89,7 +89,7 @@
     {
       "canonical_split_family": "aizynthtrain_uspto_selected_reactions_paroutes_reference_holdout",
       "dataset_ref": "aizynthtrain_uspto_selected_reactions_with_paroutes_holdout",
-      "path": "zenodo-11430881/uspto_model.onnx",
+      "path": "aizynthfinder_public_data/uspto_model.onnx",
       "split_names": [
         "train",
         "val",
@@ -115,7 +115,7 @@
     {
       "canonical_split_family": "aizynthtrain_uspto_selected_reactions_paroutes_reference_holdout",
       "dataset_ref": "aizynthtrain_uspto_selected_reactions_with_paroutes_holdout",
-      "path": "zenodo-11430881/uspto_model.onnx",
+      "path": "aizynthfinder_public_data/uspto_model.onnx",
       "split_names": [
         "train",
         "val",

checkpoints/aizynthfinder/uspto_model_onnx/provenance.json

@@ -1,7 +1,7 @@
 {
   "conversion_notes": [
     "Copied the public AiZynthFinder USPTO ONNX policy graph verbatim into model.onnx.",
-    "Bundled the matching public template CSV and optional filter/config sidecars from Zenodo record 11430881."
+    "Bundled the matching public template CSV and optional filter/config sidecars from Public record 11430881."
   ],
   "copied_sidecars": [
     "aux/config.yml",
@@ -12,100 +12,92 @@
   "normalized_checkpoint_id": "uspto_model_onnx",
   "source_artifacts": [
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/config.yml",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/config.yml",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/config.yml",
+      "path": "datasets/aizynthfinder_public_data/config.yml",
       "role": "source_artifact",
       "sha256": "51243c4b1b0a7fa4908bd8dd06de9690ea4b87d0c856caaf419a0cec32cd5da4",
       "size": 335
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/urls.txt",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/urls.txt",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/urls.txt",
+      "path": "datasets/aizynthfinder_public_data/urls.txt",
       "role": "source_artifact",
       "sha256": "014690b9f1aeb49e14c7c64da0060e371e3760090a37abe7033fadcc24ee2992",
       "size": 755
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/uspto_filter_model.hdf5",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/uspto_filter_model.hdf5",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/uspto_filter_model.hdf5",
+      "path": "datasets/aizynthfinder_public_data/uspto_filter_model.hdf5",
       "role": "source_artifact",
       "sha256": "922282e9943f9b7070865d685c4cd8f46b507028f4a0e295c3034eda9c4bd21f",
       "size": 50392960
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/uspto_filter_model.onnx",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/uspto_filter_model.onnx",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/uspto_filter_model.onnx",
+      "path": "datasets/aizynthfinder_public_data/uspto_filter_model.onnx",
       "role": "source_artifact",
       "sha256": "ad29aa32bdfcbe37065045546493806cf04899c55386c438905d83fb14bb6320",
       "size": 16788859
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/uspto_model.hdf5",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/uspto_model.hdf5",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/uspto_model.hdf5",
+      "path": "datasets/aizynthfinder_public_data/uspto_model.hdf5",
       "role": "source_artifact",
       "sha256": "75f87cc726271535868fbf3cbf9b7ac34fc97fd7540be2e3c61c1ad48c1bb4d2",
       "size": 274578664
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/uspto_model.onnx",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/uspto_model.onnx",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/uspto_model.onnx",
+      "path": "datasets/aizynthfinder_public_data/uspto_model.onnx",
       "role": "source_artifact",
       "sha256": "bd0a3cb74cd7068de474c8fb789a00a66bc42c75636d66510ccac585ebe928f8",
       "size": 91518243
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/uspto_ringbreaker_model.hdf5",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/uspto_ringbreaker_model.hdf5",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/uspto_ringbreaker_model.hdf5",
+      "path": "datasets/aizynthfinder_public_data/uspto_ringbreaker_model.hdf5",
       "role": "source_artifact",
       "sha256": "0faac874ea4c8b149aeba35479eb9063c8349fd33500d33a83db3e068bba70ad",
       "size": 45132232
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/uspto_ringbreaker_model.onnx",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/uspto_ringbreaker_model.onnx",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/uspto_ringbreaker_model.onnx",
+      "path": "datasets/aizynthfinder_public_data/uspto_ringbreaker_model.onnx",
       "role": "source_artifact",
       "sha256": "1bf0690352d9e9212d7dbe8b35649caf74f73ef0b30edefdfdac37fce38085be",
       "size": 15036094
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/uspto_ringbreaker_templates.csv.gz",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/uspto_ringbreaker_templates.csv.gz",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/uspto_ringbreaker_templates.csv.gz",
+      "path": "datasets/aizynthfinder_public_data/uspto_ringbreaker_templates.csv.gz",
       "role": "source_artifact",
       "sha256": "5616a056454b10a2f044e69e027422128986856ebd958541a3bf9f837e3a0d14",
       "size": 373753
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/uspto_templates.csv.gz",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/uspto_templates.csv.gz",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/uspto_templates.csv.gz",
+      "path": "datasets/aizynthfinder_public_data/uspto_templates.csv.gz",
       "role": "source_artifact",
       "sha256": "a4f1945e90cfa195538320833d68aed38f14e2fcc2f8afb5d958bc920edcafbe",
       "size": 3313598
     },
     {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/zenodo-11430881/zinc_stock.hdf5",
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/aizynthfinder_public_data/zinc_stock.hdf5",
       "kind": "local_repo_file",
-      "path": "datasets/zenodo-11430881/zinc_stock.hdf5",
+      "path": "datasets/aizynthfinder_public_data/zinc_stock.hdf5",
       "role": "source_artifact",
       "sha256": "ff54c334c3dfc11882d5fa3024fde3be8cf3e38f979d93a39b9be8cca1a5dc85",
       "size": 1339073560
-    },
-    {
-      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/download_aizynthfinder_11430881.sh",
-      "kind": "local_repo_file",
-      "path": "datasets/download_aizynthfinder_11430881.sh",
-      "role": "source_artifact",
-      "sha256": "6b9fb80d96a0e3b8c1ea2d484e2e2587ed53ae21c6ebea512608d523fbdce014",
-      "size": 977
     }
   ]
 }

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/SHA256SUMS

@@ -0,0 +1,35 @@
+2e1d66780fd41703250f7178778e0ed5f52e00b5bc00fc9a94a403551e62602e  aux/MAR-INF/MANIFEST.json
+228e2ef709b47fddf7290de52f4c2462c7d44bee856f83aa1ed94f3732693be7  aux/checkpoint_metadata.json
+b7f0a220dcbb261ea2dc3ac8e16c86a4b508cf012da5d5e250ab82c0dcbb9794  aux/graph2smiles_runtime/models/attention_xl.py
+59e5e707bf6298eaa63fccfcb638719f280579b08ccc969bb3075c2a07a9cc22  aux/graph2smiles_runtime/models/dgat.py
+0f9c77867fa1a53c18d893dab68a57f94bbaa326f8ff63e374860c45a11b1e6c  aux/graph2smiles_runtime/models/dgcn.py
+26260eb71e0da0f998d63c391641a6aa782171ed0c670c4f07014402a5073ff5  aux/graph2smiles_runtime/models/graph2smiles.py
+fbbbec61d02ddb6b9d90720b2d5b0a04a399a0abe9b1575ed4f8d428a7638f75  aux/graph2smiles_runtime/models/graphfeat.py
+3b85acd86c407470536395cf85b8af99dc067f67f31897c42dc00f4a32f772c3  aux/graph2smiles_runtime/models/model_utils.py
+d5c87645c9f7ebc96d23d3ae94c8692ffcd798e60e2b52d6d876505752eb007b  aux/graph2smiles_runtime/models/transformer_decoder.py
+9309e0352e4fb7f6c00b8dccd1bd4300ed91f7660533e3ace9db8e61645caa26  aux/graph2smiles_runtime/predict.py
+fb3b0374bcf3773e87926bce4160aa30bd9088e71b56b3daa617de2cb03892fa  aux/graph2smiles_runtime/train.py
+f7e98befeb3a532d72595f3f64728dbf32d2daa8ba91ad8e451eed16e31d244b  aux/graph2smiles_runtime/utils/c_calculate.so
+2f440d3b147d5eb16158a0eff7872bf54939a77f73d5569d229fac82f3e640d3  aux/graph2smiles_runtime/utils/chem_utils.py
+458944b4a15fb16f0da33e4e71b790815e2f88d49b5babf3b44a82d51a737422  aux/graph2smiles_runtime/utils/ctypes_calculator.py
+7a671fbff8a4c202c33af82fe2708f848a4aa07526ef7d90536ff655c77700ef  aux/graph2smiles_runtime/utils/data_utils.py
+4b2c0587180c996e160581861b8c6dae0dfde8dc8fd0f4112bb0b07704a168b4  aux/graph2smiles_runtime/utils/parsing.py
+0440ec0b6cee9da8e64b4397b83c6a1672ac3d134565c9aa7b758fd174c4fdf9  aux/graph2smiles_runtime/utils/preprocess_utils.py
+50e105d0a95fab34653c0ddc134bda5324f5825b3ce907d6349183f34d38627d  aux/graph2smiles_runtime/utils/rxn_graphs.py
+5474b2518dceaaa121aef3e4656d808d3f1dc73161eff0139277bc7f0c021ab3  aux/graph2smiles_runtime/utils/train_utils.py
+5553c34645ededd4e2012700cc0436ba54b061c3c7e97011e23b21c4eb05bfe8  aux/mar_files/handler.py
+a41171f185ba73107f02c9d9799767302cdcae4644900b8b07d882e9ac733d5c  aux/mar_files/models.zip
+9309e0352e4fb7f6c00b8dccd1bd4300ed91f7660533e3ace9db8e61645caa26  aux/mar_files/predict.py
+fb3b0374bcf3773e87926bce4160aa30bd9088e71b56b3daa617de2cb03892fa  aux/mar_files/train.py
+935b416024acc35678b82e34bbe023c6d38af0b77fd52a3b00867a143fd01f25  aux/mar_files/utils.zip
+ac9d2a64c0d30a7eb04b28f3bf31db8dd6cc961b22cd75afa0d76c6e2cd39126  aux/mar_files/vocab.txt
+31b461de0d6a05e238cfbf075582cd1a4e7a5f5b6c8338fabacdc65c22a62a53  aux/mar_members.json
+ae3774a5ea8b644523546904afc23078a6a0bf237199cfb993f34b90bbaae68f  aux/model_args.json
+07c37c91ceb6a19eebabdd5b83315b7deceb4ff7c5a88dd41d76bf022c1a227c  aux/safetensors_conversion.json
+ac9d2a64c0d30a7eb04b28f3bf31db8dd6cc961b22cd75afa0d76c6e2cd39126  aux/vocab.txt
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  benchmarks/default_test.jsonl
+cde971b8b51cc957662564f1082fe946d944bb16b6008ec20c5efbcda55bba4a  benchmarks/metadata.json
+7c951b8e1ce8f66298de4ce8c5667df5a0b92b76c70cf687a0e327de209f074e  manifest.json
+98105ab007959ddbb96e72d5bed1e968cc31cc62fe7f937c5140edc5febb2bb3  model.safetensors
+a06909c865f0fa89789d273b731ead8199eb49843f62cd39716dd1b968a43189  provenance.json
+d57e04e070323555022ffe938ff86af5e8e8373b28440c0884482509d65b9e93  wrapper_config.json

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/MAR-INF/MANIFEST.json

@@ -0,0 +1,10 @@
+{
+  "archiverVersion": "0.3.1",
+  "createdOn": "19/10/2024 01:31:37",
+  "model": {
+    "handler": "handler.py",
+    "modelName": "pistachio_clean_Q3",
+    "modelVersion": "1.0"
+  },
+  "runtime": "python"
+}

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/checkpoint_metadata.json

@@ -0,0 +1,10 @@
+{
+  "checkpoint_keys": [
+    "args",
+    "optimizer",
+    "scheduler",
+    "state_dict",
+    "total_step"
+  ],
+  "total_step": 280000
+}

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/graph2smiles_runtime/predict.py

@@ -0,0 +1,254 @@
+import argparse
+import datetime
+import glob
+import numpy as np
+import os
+import sys
+import time
+import torch
+import torch.distributed as dist
+from models.graph2smiles import Graph2SMILES
+from torch.utils.data import DataLoader, SequentialSampler
+from torch.utils.data.distributed import DistributedSampler
+from train import get_model
+from utils import parsing
+from utils.data_utils import canonicalize_smiles, load_vocab, G2SDataset
+from utils.train_utils import log_tensor, log_rank_0, param_count, set_seed, setup_logger
+
+
+def get_predict_parser():
+    parser = argparse.ArgumentParser("predict")
+    parsing.add_common_args(parser)
+    parsing.add_preprocess_args(parser)
+    parsing.add_train_args(parser)
+    parsing.add_predict_args(parser)
+
+    return parser
+
+
+def get_predictions(args, model, vocab_tokens, test_loader, device, start, multiplier=1):
+    all_predictions = []
+
+    log_rank_0(f"nbest = {(args.n_best * multiplier)}")
+    
+    with torch.no_grad():
+        for test_idx, test_batch in enumerate(test_loader):
+            if test_idx % args.log_iter == 0:
+                log_rank_0(f"Doing inference on test step {test_idx}, "
+                           f"time: {time.time() - start: .2f} s")
+
+            test_batch.to(device)
+            results = model.predict_step(
+                reaction_batch=test_batch,
+                batch_size=test_batch.size,
+                beam_size=args.beam_size,
+                n_best=args.n_best * multiplier,
+                temperature=args.temperature,
+                min_length=args.predict_min_len,
+                max_length=args.predict_max_len
+            )
+
+            for predictions, scores in zip(results["predictions"], results["scores"]):
+                smis_with_scores = []
+                for prediction, score in zip(predictions, scores):
+                    predicted_idx = prediction.detach().cpu().numpy()
+                    score = score.detach().cpu().numpy()
+                    predicted_tokens = [vocab_tokens[idx] for idx in predicted_idx[:-1]]
+                    smi = "".join(predicted_tokens)
+                    smis_with_scores.append(f"{smi}_{score}")
+                smis_with_scores = ",".join(smis_with_scores)
+                all_predictions.append(f"{smis_with_scores}\n")
+
+    return all_predictions
+
+
+def main(args):
+    args.device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+    device = args.device
+    if args.local_rank != -1:
+        dist.init_process_group(backend=args.backend, init_method='env://', timeout=datetime.timedelta(0, 7200))
+        torch.cuda.set_device(args.local_rank)
+        torch.backends.cudnn.benchmark = True
+
+    if torch.distributed.is_initialized():
+        log_rank_0(f"Device rank: {torch.distributed.get_rank()}")
+    os.makedirs(os.path.join("./results", args.data_name), exist_ok=True)
+    # os.makedirs(os.path.join("./results", args.test_output_path), exist_ok=True)
+
+    parsing.log_args(args, phase="prediction")
+
+    # initialization ---------------------------------- ckpt parsing
+    if args.do_validate:
+        checkpoints = glob.glob(os.path.join(args.load_from, "*.pt"))
+        checkpoints = sorted(
+            checkpoints,
+            key=lambda ckpt: int(ckpt.split(".")[-2].split("_")[-1]),
+            reverse=True
+        )
+        multipliers = [3] * len(checkpoints)
+        checkpoints = [ckpt for ckpt in checkpoints
+                       if (args.checkpoint_step_start <= int(ckpt.split(".")[-2].split("_")[1]))
+                       and (args.checkpoint_step_end >= int(ckpt.split(".")[-2].split("_")[1]))]
+        file_bin = os.path.join(args.processed_data_path, "val.npz")
+        file_tgt = os.path.join(args.processed_data_path, "tgt-val.txt")
+    elif args.do_predict:
+        # multipliers = [1, 3, 5, 10, 20]
+        multipliers = [3]
+        checkpoints = [os.path.join(args.model_path, args.load_from)]
+        file_bin = os.path.join(args.processed_data_path, "test.npz")
+        file_tgt = os.path.join(args.processed_data_path, "tgt-test.txt")
+    else:
+        raise ValueError("Either --do_validate or --do_predict need to be specified!")
+
+    model = None
+    test_dataset = None
+    vocab_tokens = None
+    smis_tgt = []
+    start = time.time()
+    for ckpt_i, checkpoint in enumerate(checkpoints):
+        result_file = os.path.join(args.test_output_path, f"result.{ckpt_i}")
+        result_stat_file = os.path.join(args.test_output_path, f"result.stat.{ckpt_i}")
+
+        if os.path.exists(result_file) and False:
+            log_rank_0(f"Result file found at {result_file}, skipping prediction.")
+        else:
+            log_rank_0(f"Loading from {checkpoint}")
+            try:
+                state = torch.load(checkpoint)
+            except RuntimeError:
+                log_rank_0(f"Error loading {checkpoint}, skipping")
+                continue            # some weird corrupted files
+
+            pretrain_args = state["args"]
+            pretrain_args.load_from = None     
+            pretrain_state_dict = state["state_dict"]
+            pretrain_args.local_rank = args.local_rank
+            if not hasattr(pretrain_args, "n_latent"):
+                pretrain_args.n_latent = 1
+            args.n_latent = pretrain_args.n_latent
+            if not hasattr(pretrain_args, "shared_attention_layer"):
+                pretrain_args.shared_attention_layer = 0
+
+            if model is None:
+                # initialization ---------------------------------- model
+                log_rank_0("Model is None, building model")
+                log_rank_0("First logging args for training")
+                parsing.log_args(pretrain_args, phase="training")
+
+                # backward
+                assert args.model == pretrain_args.model or \
+                    pretrain_args.model == "g2s_series_rel", \
+                    f"Pretrained model is {pretrain_args.model}!"
+                model_class = Graph2SMILES
+                dataset_class = G2SDataset
+                args.compute_graph_distance = True
+
+                # initialization ---------------------------------- vocab
+                vocab = load_vocab(args)
+                vocab_tokens = [k for k, v in sorted(vocab.items(), key=lambda tup: tup[1])]
+
+                model, state = get_model(pretrain_args, model_class, vocab, device)
+                if hasattr(model, "module"):
+                    model = model.module        # unwrap DDP model to enable accessing model func directly
+
+                log_rank_0(model)
+                log_rank_0(f"Number of parameters = {param_count(model)}")
+
+                # initialization ---------------------------------- data
+                test_dataset = dataset_class(args, file=file_bin)
+                test_dataset.batch(
+                    batch_type=args.batch_type,
+                    batch_size=args.predict_batch_size
+                )
+                with open(file_tgt, "r") as f:
+                    total = sum(1 for _ in f)
+
+                with open(file_tgt, "r") as f:
+                    for line_tgt in f:
+                        smi_tgt = "".join(line_tgt.split())
+                        smi_tgt = canonicalize_smiles(smi_tgt)
+                        smis_tgt.append(smi_tgt)
+
+            pretrain_state_dict = {k.replace("module.", ""): v for k, v in pretrain_state_dict.items()}
+            model.load_state_dict(pretrain_state_dict)
+            log_rank_0(f"Loaded pretrained state_dict from {checkpoint}")
+            model.eval()
+
+            if args.local_rank != -1:
+                test_sampler = DistributedSampler(test_dataset, shuffle=False)
+            else:
+                test_sampler = SequentialSampler(test_dataset)
+
+            test_loader = DataLoader(
+                dataset=test_dataset,
+                batch_size=1,
+                sampler=test_sampler,
+                num_workers=args.num_cores,
+                collate_fn=lambda _batch: _batch[0],
+                pin_memory=True
+            )
+
+            multiplier = multipliers[ckpt_i]
+            all_predictions = get_predictions(
+                args, model, vocab_tokens, test_loader, device, start, multiplier)
+
+            if args.local_rank > 0:
+                continue
+
+            # saving prediction results
+            with open(result_file, "w") as of:
+                of.writelines(all_predictions)
+
+        if args.do_score:
+            if os.path.exists(result_stat_file) and False:
+                log_rank_0(f"Result stat file found at {result_stat_file}, skipping scoring.")
+                continue
+
+            invalid = 0
+            accuracies = np.zeros([total, args.n_best], dtype=np.float32)
+
+            with open(result_file, "r") as f_predict:
+                for i, (smi_tgt, line_predict) in enumerate(zip(smis_tgt, f_predict)):
+                    if smi_tgt == "CC":         # problematic SMILES
+                        continue
+
+                    line_predict = "".join(line_predict.split())
+                    smis_predict = line_predict.split(",")
+                    smis_predict = [smi.split("_")[0] for smi in smis_predict]
+                    smis_predict = [canonicalize_smiles(smi, trim=False, suppress_warning=True) for smi in smis_predict]
+                    if not smis_predict[0]:
+                        invalid += 1
+                    smis_predict = [smi for smi in smis_predict if smi and not smi == "CC"]
+                    smis_predict = list(dict.fromkeys(smis_predict))
+
+                    for j, smi in enumerate(smis_predict[:args.n_best]):
+                        if smi == smi_tgt:
+                            accuracies[i, j:] = 1.0
+                            break
+
+            with open(result_stat_file, "w") as of:
+                line = f"Total: {total}, top 1 invalid: {invalid / total * 100: .2f} %"
+                log_rank_0(line)
+                of.write(f"{line}\n")
+
+                mean_accuracies = np.mean(accuracies, axis=0)
+                for n in range(args.n_best):
+                    line = f"Top {n+1} accuracy: {mean_accuracies[n] * 100: .2f} %"
+                    log_rank_0(line)
+                    of.write(f"{line}\n")
+
+            log_rank_0(f"Elapsed time: {time.time() - start: .2f} s")
+
+
+if __name__ == "__main__":
+    # initialization ---------------------------------- args, logs and devices
+    predict_parser = get_predict_parser()
+    args = predict_parser.parse_args()
+
+    setup_logger(args, warning_off=True)
+    np.set_printoptions(threshold=sys.maxsize)
+    torch.set_printoptions(profile="full")
+
+    set_seed(args.seed)
+
+    main(args)

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/graph2smiles_runtime/train.py

@@ -0,0 +1,287 @@
+import argparse
+import datetime
+import logging
+import numpy as np
+import os
+import sys
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+import torch.optim as optim
+from models.graph2smiles import Graph2SMILES
+import time
+from torch.nn.init import xavier_uniform_
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
+from torch.utils.data.distributed import DistributedSampler
+from typing import Dict
+from utils import parsing
+from utils.data_utils import G2SDataset
+from utils.preprocess_utils import load_vocab
+from utils.train_utils import get_lr, grad_norm, log_rank_0, NoamLR, \
+    param_count, param_norm, set_seed, setup_logger
+
+
+def get_train_parser():
+    parser = argparse.ArgumentParser("train")
+    parsing.add_common_args(parser)
+    parsing.add_train_args(parser)
+    parsing.add_predict_args(parser)
+
+    return parser
+
+
+def init_dist(args):
+    if args.local_rank != -1:
+        dist.init_process_group(backend=args.backend,
+                                init_method='env://',
+                                timeout=datetime.timedelta(0, 7200))
+        torch.cuda.set_device(args.local_rank)
+        torch.backends.cudnn.benchmark = False
+
+    if dist.is_initialized():
+        logging.info(f"Device rank: {dist.get_rank()}")
+        sys.stdout.flush()
+
+
+def get_model(args, model_class, vocab: Dict[str, int], device):
+    state = {}
+    if args.load_from:
+        log_rank_0(f"Loading pretrained state from {args.load_from}")
+        state = torch.load(args.load_from, map_location=torch.device("cpu"))
+        pretrain_args = state["args"]
+        pretrain_args.local_rank = args.local_rank
+        parsing.log_args(pretrain_args, phase="pretraining")
+
+        model = model_class(pretrain_args, vocab)
+        pretrain_state_dict = state["state_dict"]
+        pretrain_state_dict = {k.replace("module.", ""): v for k, v in pretrain_state_dict.items()}
+        model.load_state_dict(pretrain_state_dict)
+        log_rank_0("Loaded pretrained model state_dict.")
+    else:
+        model = model_class(args, vocab)
+        for p in model.parameters():
+            if p.dim() > 1 and p.requires_grad:
+                xavier_uniform_(p)
+
+    model.to(device)
+    if args.local_rank != -1:
+        model = DDP(
+            model,
+            device_ids=[args.local_rank],
+            output_device=args.local_rank
+        )
+        log_rank_0("DDP setup finished")
+
+    return model, state
+
+
+def get_optimizer_and_scheduler(args, model, state):
+    optimizer = optim.AdamW(
+        model.parameters(),
+        lr=args.lr,
+        betas=(args.beta1, args.beta2),
+        eps=args.eps,
+        weight_decay=args.weight_decay
+    )
+    scheduler = NoamLR(
+        optimizer,
+        model_size=args.decoder_hidden_size,
+        warmup_steps=args.warmup_steps
+    )
+
+    if state and args.resume:
+        optimizer.load_state_dict(state["optimizer"])
+        scheduler.load_state_dict(state["scheduler"])
+        log_rank_0("Loaded pretrained optimizer and scheduler state_dicts.")
+
+    return optimizer, scheduler
+
+
+def init_loader(args, dataset, batch_size: int, bucket_size: int = 1000,
+                shuffle: bool = False, epoch: int = None):
+    dataset.sort()
+    dataset.shuffle_in_bucket(bucket_size=bucket_size)
+    dataset.batch(
+        batch_type=args.batch_type,
+        batch_size=batch_size
+    )
+
+    if args.local_rank != -1:
+        sampler = DistributedSampler(dataset, shuffle=shuffle)
+        if epoch is not None:
+            sampler.set_epoch(epoch)
+    else:
+        sampler = RandomSampler(dataset) if shuffle else SequentialSampler(dataset)
+
+    loader = DataLoader(
+        dataset=dataset,
+        batch_size=1,
+        sampler=sampler,
+        num_workers=args.num_cores,
+        collate_fn=lambda _batch: _batch[0],
+        pin_memory=True
+    )
+
+    return loader
+
+
+def _optimize(args, model, optimizer, scheduler, accum_count):
+    # for param in model.parameters():
+    #     param.grad /= accum_count
+
+    nn.utils.clip_grad_norm_(model.parameters(), args.clip_norm)
+    optimizer.step()
+    scheduler.step()
+    g_norm = grad_norm(model)
+    model.zero_grad(set_to_none=True)
+
+    return g_norm
+
+
+def train_main(args):
+    args.device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+    device = args.device
+
+    init_dist(args)
+    parsing.log_args(args, phase="training")
+
+    vocab_file = os.path.join(args.processed_data_path, "vocab.txt")
+    if not os.path.exists(vocab_file):
+        raise ValueError(f"Vocab file {vocab_file} not found!")
+    vocab = load_vocab(args)
+
+    os.makedirs(args.model_path, exist_ok=True)
+    model_class = Graph2SMILES
+    dataset_class = G2SDataset
+    assert args.compute_graph_distance
+
+    model, state = get_model(args, model_class, vocab, device)
+    log_rank_0(model)
+    log_rank_0(f"Number of parameters = {param_count(model)}")
+
+    optimizer, scheduler = get_optimizer_and_scheduler(args, model, state)
+
+    train_bin = os.path.join(args.processed_data_path, "train.npz")
+    val_bin = os.path.join(args.processed_data_path, "val.npz")
+
+    train_dataset = dataset_class(args, file=train_bin)
+    val_dataset = dataset_class(args, file=val_bin)
+
+    total_step = state["total_step"] if state else 0
+    accum = 0
+    g_norm = 0
+    losses, accs, ems = [], [], []
+    o_start = time.time()
+    log_rank_0("Start training")
+
+    for epoch in range(args.epoch):
+        model.train()
+        model.zero_grad(set_to_none=True)
+        train_loader = init_loader(args, train_dataset,
+                                   batch_size=args.train_batch_size,
+                                   shuffle=True,
+                                   epoch=epoch)
+        for batch_idx, train_batch in enumerate(train_loader):
+            
+            if train_batch is None:
+                log_rank_0("Fail distance compute, too large due to node size")
+                continue
+
+            if total_step > args.max_steps:
+                log_rank_0("Max steps reached, finish training")
+                exit(0)
+            train_batch.to(device)
+            batch_losses, acc, em = model(train_batch)
+            loss = batch_losses.mean()
+            (loss / args.accumulation_count).backward() # average out the loss over multiple batches during accumulation
+            losses.append(loss.item())
+            accs.append(acc.item() * 100)
+            ems.append(em.item() * 100)
+
+            accum += 1
+            if accum == args.accumulation_count:
+                g_norm = _optimize(args, model, optimizer, scheduler, args.accumulation_count)
+                accum = 0
+                total_step += 1
+
+            if (accum == 0) and (total_step > 0) and (total_step % args.log_iter == 0):
+                log_rank_0(f"Step {total_step}, loss: {np.mean(losses)}, "
+                           f"acc: {np.mean(accs): .4f}, em: {np.mean(ems): .4f}, "
+                           f"p_norm: {param_norm(model): .4f}, g_norm: {g_norm: .4f}, "
+                           f"lr: {get_lr(optimizer): .6f}, "
+                           f"elapsed time: {time.time() - o_start: .0f}")
+                losses, accs, ems = [], [], []
+
+            if (accum == 0) and (total_step > 0) and (total_step % args.eval_iter == 0):
+                model.eval()
+                val_count = 100
+                val_losses, val_accs, val_ems = [], [], []
+
+                val_loader = init_loader(args, val_dataset,
+                                         batch_size=args.val_batch_size,
+                                         shuffle=True,
+                                         epoch=None)
+                with torch.no_grad():
+                    for val_idx, val_batch in enumerate(val_loader):
+                        if val_batch is None:
+                            log_rank_0("Fail distance compute, too large due to node size")
+                            continue
+
+                        if val_idx >= val_count:
+                            break
+                        val_batch.to(device)
+                        val_batch_losses, val_acc, val_em = model(val_batch)
+                        val_loss = val_batch_losses.mean()
+                        val_losses.append(val_loss.item())
+                        val_accs.append(val_acc.item() * 100)
+                        val_ems.append(val_em.item() * 100)
+
+                log_rank_0(f"Validation (with teacher) at step {total_step}, "
+                           f"val loss: {np.mean(val_losses)}, "
+                           f"val acc: {np.mean(val_accs): .4f}, "
+                           f"val em: {np.mean(val_ems): .4f}")
+                model.train()
+
+            # Important: saving only at one node or the ckpt would be corrupted!
+            if dist.is_initialized() and dist.get_rank() > 0:
+                continue
+
+            if (accum == 0) and (total_step > 0) and (total_step % args.save_iter == 0):
+                n_iter = total_step // args.save_iter - 1
+                log_rank_0(f"Saving at step {total_step}")
+                state = {
+                    "args": args,
+                    "total_step": total_step,
+                    "state_dict": model.state_dict(),
+                    "optimizer": optimizer.state_dict(),
+                    "scheduler": scheduler.state_dict()
+                }
+                torch.save(state, os.path.join(args.model_path, f"model.{total_step}_{n_iter}.pt"))
+
+        # lastly
+        if (args.accumulation_count > 1) and (accum > 0):
+            g_norm = _optimize(args, model, optimizer, scheduler, args.accumulation_count)
+            accum = 0
+            # total_step += 1           # for partial batch, do not increase total_step
+
+        if args.local_rank != -1:
+            dist.barrier()
+
+
+if __name__ == "__main__":
+    train_parser = get_train_parser()
+    args = train_parser.parse_args()
+
+    # set random seed
+    set_seed(args.seed)
+
+    # logger setup
+    logger = setup_logger(args)
+
+    # maximize display for debugging
+    np.set_printoptions(threshold=sys.maxsize)
+    torch.set_printoptions(profile="full")
+
+    args.local_rank = int(os.environ["LOCAL_RANK"]) if os.environ.get("LOCAL_RANK") else -1
+    train_main(args)

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/graph2smiles_runtime/utils/chem_utils.py

@@ -0,0 +1,144 @@
+from rdkit import Chem
+from typing import List
+
+
+# Symbols for different atoms
+ATOM_LIST = ['C', 'N', 'O', 'S', 'F', 'Si', 'P', 'Cl', 'Br', 'Mg', 'Na', 'Ca', 'Fe',
+             'As', 'Al', 'I', 'B', 'V', 'K', 'Tl', 'Yb', 'Sb', 'Sn', 'Ag', 'Pd', 'Co', 'Se', 'Ti',
+             'Zn', 'H', 'Li', 'Ge', 'Cu', 'Au', 'Ni', 'Cd', 'In', 'Mn', 'Zr', 'Cr', 'Pt', 'Hg', 'Pb',
+             'W', 'Ru', 'Nb', 'Re', 'Te', 'Rh', 'Ta', 'Tc', 'Ba', 'Bi', 'Hf', 'Mo', 'U', 'Sm', 'Os', 'Ir',
+             'Ce', 'Gd', 'Ga', 'Cs', '*', 'unk']
+ATOM_DICT = {symbol: i for i, symbol in enumerate(ATOM_LIST)}
+
+MAX_NB = 10
+DEGREES = list(range(MAX_NB))
+HYBRIDIZATION = [Chem.rdchem.HybridizationType.SP,
+                 Chem.rdchem.HybridizationType.SP2,
+                 Chem.rdchem.HybridizationType.SP3,
+                 Chem.rdchem.HybridizationType.SP3D,
+                 Chem.rdchem.HybridizationType.SP3D2]
+HYBRIDIZATION_DICT = {hb: i for i, hb in enumerate(HYBRIDIZATION)}
+
+FORMAL_CHARGE = [-1, -2, 1, 2, 0]
+FC_DICT = {fc: i for i, fc in enumerate(FORMAL_CHARGE)}
+
+VALENCE = [0, 1, 2, 3, 4, 5, 6]
+VALENCE_DICT = {vl: i for i, vl in enumerate(VALENCE)}
+
+NUM_Hs = [0, 1, 2, 3, 4]
+NUM_Hs_DICT = {nH: i for i, nH in enumerate(NUM_Hs)}
+
+CHIRAL_TAG = [Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CW,
+              Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CCW,
+              Chem.rdchem.ChiralType.CHI_UNSPECIFIED]
+CHIRAL_TAG_DICT = {ct: i for i, ct in enumerate(CHIRAL_TAG)}
+
+RS_TAG = ["R", "S", "None"]
+RS_TAG_DICT = {rs: i for i, rs in enumerate(RS_TAG)}
+
+BOND_TYPES = [None,
+              Chem.rdchem.BondType.SINGLE,
+              Chem.rdchem.BondType.DOUBLE,
+              Chem.rdchem.BondType.TRIPLE,
+              Chem.rdchem.BondType.AROMATIC]
+BOND_TYPES_DICT = {bt: i for i, bt in enumerate(BOND_TYPES)}
+
+BOND_FLOAT_TO_TYPE = {
+    0.0: BOND_TYPES[0],
+    1.0: BOND_TYPES[1],
+    2.0: BOND_TYPES[2],
+    3.0: BOND_TYPES[3],
+    1.5: BOND_TYPES[4],
+}
+
+BOND_STEREO = [Chem.rdchem.BondStereo.STEREOE,
+               Chem.rdchem.BondStereo.STEREOZ,
+               Chem.rdchem.BondStereo.STEREONONE]
+BOND_STEREO_DICT = {bs: i for i, bs in enumerate(BOND_STEREO)}
+
+BOND_DELTAS = {-3: 0, -2: 1, -1.5: 2, -1: 3, -0.5: 4, 0: 5, 0.5: 6, 1: 7, 1.5: 8, 2: 9, 3: 10}
+BOND_FLOATS = [0.0, 1.0, 2.0, 3.0, 1.5]
+
+RXN_CLASSES = list(range(10))
+
+# ATOM_FDIM = len(ATOM_LIST) + len(DEGREES) + len(FORMAL_CHARGE) + len(HYBRIDIZATION) \
+#             + len(VALENCE) + len(NUM_Hs) + 1
+ATOM_FDIM = [len(ATOM_LIST), len(DEGREES), len(FORMAL_CHARGE), len(HYBRIDIZATION), len(VALENCE),
+             len(NUM_Hs), len(CHIRAL_TAG), len(RS_TAG), 2]
+# BOND_FDIM = 6
+BOND_FDIM = 9
+BOND_FDIMS = [5, 3, 2, 2]
+BINARY_FDIM = 5 + BOND_FDIM
+INVALID_BOND = -1
+
+
+def get_atom_features_sparse(atom: Chem.Atom) -> List[int]:
+    """Get atom features as sparse idx.
+
+    Parameters
+    ----------
+    atom: Chem.Atom,
+        Atom object from RDKit
+    """
+    feature_array = []
+    symbol = atom.GetSymbol()
+    symbol_id = ATOM_DICT.get(symbol, ATOM_DICT["unk"])
+    feature_array.append(symbol_id)
+
+    if symbol in ["*", "unk"]:
+        padding = [999999999] * len(ATOM_FDIM)
+        feature_array.extend(padding)
+
+    else:
+        degree_id = atom.GetDegree()
+        if degree_id not in DEGREES:
+            degree_id = 9
+        formal_charge_id = FC_DICT.get(atom.GetFormalCharge(), 4)
+        hybridization_id = HYBRIDIZATION_DICT.get(atom.GetHybridization(), 4)
+        valence_id = VALENCE_DICT.get(atom.GetTotalValence(), 6)
+        num_h_id = NUM_Hs_DICT.get(atom.GetTotalNumHs(), 0)
+        chiral_tag_id = CHIRAL_TAG_DICT.get(atom.GetChiralTag(), 2)
+
+        rs_tag = atom.GetPropsAsDict().get("_CIPCode", "None")
+        rs_tag_id = RS_TAG_DICT.get(rs_tag, 2)
+
+        is_aromatic = int(atom.GetIsAromatic())
+        feature_array.extend([degree_id, formal_charge_id, hybridization_id,
+                              valence_id, num_h_id, chiral_tag_id, rs_tag_id, is_aromatic])
+
+        # legacy; for reaction class
+        feature_array.append(0)
+
+    return feature_array
+
+
+def get_bond_features(bond: Chem.Bond) -> List[int]:
+    """Get bond features.
+
+    Parameters
+    ----------
+    bond: Chem.Bond,
+        bond object
+    """
+    bt = bond.GetBondType()
+    bond_features = [int(bt == bond_type) for bond_type in BOND_TYPES[1:]]
+    bs = bond.GetStereo()
+    bond_features.extend([int(bs == bond_stereo) for bond_stereo in BOND_STEREO])
+    bond_features.extend([int(bond.GetIsConjugated()), int(bond.IsInRing())])
+
+    return bond_features
+
+
+def get_bond_features_sparse(bond: Chem.Bond) -> List[int]:
+    """Get bond features.
+
+    Parameters
+    ----------
+    bond: Chem.Bond,
+        bond object
+    """
+    bt = BOND_TYPES_DICT.get(bond.GetBondType(), 0)
+    bs = BOND_STEREO_DICT.get(bond.GetStereo(), 2)
+    bond_features = [bt, bs, int(bond.GetIsConjugated()), int(bond.IsInRing())]
+
+    return bond_features

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/graph2smiles_runtime/utils/ctypes_calculator.py

@@ -0,0 +1,35 @@
+import ctypes
+import numpy as np
+import numpy.ctypeslib as npct
+
+
+class DistanceCalculator:
+    # Declare an alias for the C type int*, equivalent to int[]
+    array_1d_uint8 = npct.ndpointer(dtype=np.uint8, ndim=1, flags="C_CONTIGUOUS")
+    array_1d_bool = npct.ndpointer(dtype=np.bool_, ndim=1, flags="C_CONTIGUOUS")
+
+    # Load c_func.so into my_lib; my_lib.c_func is now callable
+    my_lib = npct.load_library("c_calculate", "./utils")
+
+    my_lib.c_calculate.restype = None        # return type
+    my_lib.c_calculate.argtypes = [          # args type
+        array_1d_uint8, ctypes.c_int32,
+        array_1d_bool,
+        ctypes.c_int32
+    ]
+
+    @staticmethod
+    def calculate(adjacency: np.ndarray,
+                  a_length: int,
+                  max_distance: int) -> np.ndarray:
+        flattened_distance = np.zeros(a_length * a_length, dtype=np.uint8)
+        flattened_adjacency = adjacency.ravel()
+
+        DistanceCalculator.my_lib.c_calculate(
+            flattened_distance, a_length,
+            flattened_adjacency,
+            max_distance
+        )
+        distance = flattened_distance.reshape(a_length, a_length)
+
+        return distance

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/graph2smiles_runtime/utils/data_utils.py

@@ -0,0 +1,512 @@
+import logging
+import numpy as np
+import os
+import time
+import torch
+from rdkit import Chem
+from torch.utils.data import Dataset
+from typing import List, Tuple
+from utils.chem_utils import ATOM_FDIM, BOND_FDIM, get_atom_features_sparse
+from utils.ctypes_calculator import DistanceCalculator
+from utils.preprocess_utils import load_vocab
+from utils.train_utils import log_rank_0
+
+
+def len2idx(lens) -> np.ndarray:
+    end_indices = np.cumsum(lens)
+    start_indices = np.concatenate([[0], end_indices[:-1]], axis=0)
+    indices = np.stack([start_indices, end_indices], axis=1)
+
+    return indices
+
+
+def canonicalize_smiles(smiles, remove_atom_number=True, trim=True, suppress_warning=False):
+    mol = Chem.MolFromSmiles(smiles)
+
+    if mol is None:
+        cano_smiles = ""
+
+    else:
+        try:
+            if trim and mol.GetNumHeavyAtoms() < 2:
+                if not suppress_warning:
+                    logging.info(f"Problematic smiles: {smiles}, setting it to 'CC'")
+                cano_smiles = "CC"          # TODO: hardcode to ignore
+            else:
+                if remove_atom_number:
+                    [a.ClearProp('molAtomMapNumber') for a in mol.GetAtoms()]
+                cano_smiles = Chem.MolToSmiles(mol, isomericSmiles=True)
+        except RuntimeError as e:
+            cano_smiles = ""
+
+    return cano_smiles
+
+
+class G2SBatch:
+    def __init__(self,
+                 fnode: torch.Tensor,
+                 fmess: torch.Tensor,
+                 agraph: torch.Tensor,
+                 bgraph: torch.Tensor,
+                 atom_scope: List,
+                 bond_scope: List,
+                 tgt_token_ids: torch.Tensor,
+                 tgt_lengths: torch.Tensor,
+                 distances: torch.Tensor = None):
+        self.fnode = fnode
+        self.fmess = fmess
+        self.agraph = agraph
+        self.bgraph = bgraph
+        self.atom_scope = atom_scope
+        self.bond_scope = bond_scope
+        self.tgt_token_ids = tgt_token_ids
+        self.tgt_lengths = tgt_lengths
+        self.distances = distances
+
+        self.size = len(tgt_lengths)
+
+    def to(self, device):
+        self.fnode = self.fnode.to(device)
+        self.fmess = self.fmess.to(device)
+        self.agraph = self.agraph.to(device)
+        self.bgraph = self.bgraph.to(device)
+        self.tgt_token_ids = self.tgt_token_ids.to(device)
+        self.tgt_lengths = self.tgt_lengths.to(device)
+
+        if self.distances is not None:
+            self.distances = self.distances.to(device)
+
+    def pin_memory(self):
+        self.fnode = self.fnode.pin_memory()
+        self.fmess = self.fmess.pin_memory()
+        self.agraph = self.agraph.pin_memory()
+        self.bgraph = self.bgraph.pin_memory()
+        self.tgt_token_ids = self.tgt_token_ids.pin_memory()
+        self.tgt_lengths = self.tgt_lengths.pin_memory()
+
+        if self.distances is not None:
+            self.distances = self.distances.pin_memory()
+
+        return self
+
+    def log_tensor_shape(self):
+        log_rank_0(f"fnode: {self.fnode.shape}, "
+                   f"fmess: {self.fmess.shape}, "
+                   f"tgt_token_ids: {self.tgt_token_ids.shape}, "
+                   f"tgt_lengths: {self.tgt_lengths}")
+
+
+class G2SDataset(Dataset):
+    def __init__(self, args, file: str):
+        self.args = args
+
+        self.a_scopes = []
+        self.b_scopes = []
+        self.a_features = []
+        self.b_features = []
+        self.a_graphs = []
+        self.b_graphs = []
+        self.a_scopes_lens = []
+        self.b_scopes_lens = []
+        self.a_features_lens = []
+        self.b_features_lens = []
+
+        self.src_token_ids = []             # loaded but not batched
+        self.src_lens = []
+        self.tgt_token_ids = []
+        self.tgt_lens = []
+
+        self.data_indices = []
+        self.batch_sizes = []
+        self.batch_starts = []
+        self.batch_ends = []
+
+        self.vocab = load_vocab(args)
+        self.vocab_tokens = [k for k, v in sorted(self.vocab.items(), key=lambda tup: tup[1])]
+
+        log_rank_0(f"Loading preprocessed features from {file}")
+        feat = np.load(file)
+        for attr in ["a_scopes", "b_scopes", "a_features", "b_features", "a_graphs", "b_graphs",
+                     "a_scopes_lens", "b_scopes_lens", "a_features_lens", "b_features_lens",
+                     "src_token_ids", "src_lens", "tgt_token_ids", "tgt_lens"]:
+            setattr(self, attr, feat[attr])
+
+        # mask out chiral tag (as UNSPECIFIED)
+        if args.mask_rel_chirality == 1:
+            self.a_features[:, 6] = 2
+
+        assert len(self.a_scopes_lens) == len(self.b_scopes_lens) == \
+               len(self.a_features_lens) == len(self.b_features_lens) == \
+               len(self.src_token_ids) == len(self.src_lens) == \
+               len(self.tgt_token_ids) == len(self.tgt_lens), \
+               f"Lengths of source and target mismatch!"
+
+        self.a_scopes_indices = len2idx(self.a_scopes_lens)
+        self.b_scopes_indices = len2idx(self.b_scopes_lens)
+        self.a_features_indices = len2idx(self.a_features_lens)
+        self.b_features_indices = len2idx(self.b_features_lens)
+
+        del self.a_scopes_lens, self.b_scopes_lens, self.a_features_lens, self.b_features_lens
+
+        self.data_size = len(self.src_token_ids)
+        self.data_indices = np.arange(self.data_size)
+
+        self.distance_calculator = None
+        if self.args.compute_graph_distance:
+            self.distance_calculator = DistanceCalculator()
+
+        log_rank_0(f"Loaded and initialized G2SDataset, size: {self.data_size}")
+
+    def sort(self):
+        if self.args.verbose:
+            start = time.time()
+            log_rank_0("Calling G2SDataset.sort()")
+            self.data_indices = np.argsort(self.src_lens)
+            log_rank_0(f"Done, time: {time.time() - start: .2f} s")
+        else:
+            self.data_indices = np.argsort(self.src_lens)
+
+    def shuffle_in_bucket(self, bucket_size: int):
+        if self.args.verbose:
+            start = time.time()
+            log_rank_0("Calling G2SDataset.shuffle_in_bucket()")
+            for i in range(0, self.data_size, bucket_size):
+                np.random.shuffle(self.data_indices[i:i+bucket_size])
+            log_rank_0(f"Done, time: {time.time() - start: .2f} s")
+        else:
+            for i in range(0, self.data_size, bucket_size):
+                np.random.shuffle(self.data_indices[i:i + bucket_size])
+
+    def batch(self, batch_type: str, batch_size: int):
+        start = time.time()
+        log_rank_0("Calling G2SDataset.batch()")
+
+        self.batch_sizes = []
+        if batch_type in ["samples", "atoms"]:
+            raise NotImplementedError
+
+        elif batch_type.startswith("tokens"):
+            sample_size = 0
+            max_batch_src_len = 0
+            max_batch_tgt_len = 0
+
+            for data_idx in self.data_indices:
+                src_len = self.src_lens[data_idx]
+                tgt_len = self.tgt_lens[data_idx]
+
+                max_batch_src_len = max(src_len, max_batch_src_len)
+                max_batch_tgt_len = max(tgt_len, max_batch_tgt_len)
+                while self.args.enable_amp and not max_batch_src_len % 8 == 0:  # for amp
+                    max_batch_src_len += 1
+                while self.args.enable_amp and not max_batch_tgt_len % 8 == 0:  # for amp
+                    max_batch_tgt_len += 1
+
+                if batch_type == "tokens" and \
+                        max_batch_src_len * (sample_size + 1) <= batch_size:
+                    sample_size += 1
+                elif batch_type == "tokens_sum" and \
+                        (max_batch_src_len + max_batch_tgt_len) * (sample_size + 1) <= batch_size:
+                    sample_size += 1
+                elif self.args.enable_amp and not sample_size % 8 == 0:
+                    sample_size += 1
+                else:
+                    self.batch_sizes.append(sample_size)
+
+                    sample_size = 1
+                    max_batch_src_len = src_len
+                    max_batch_tgt_len = tgt_len
+                    while self.args.enable_amp and not max_batch_src_len % 8 == 0:  # for amp
+                        max_batch_src_len += 1
+                    while self.args.enable_amp and not max_batch_tgt_len % 8 == 0:  # for amp
+                        max_batch_tgt_len += 1
+
+            # lastly
+            self.batch_sizes.append(sample_size)
+            self.batch_sizes = np.array(self.batch_sizes)
+            assert np.sum(self.batch_sizes) == self.data_size, \
+                f"Size mismatch! Data size: {self.data_size}, sum batch sizes: {np.sum(self.batch_sizes)}"
+
+            self.batch_ends = np.cumsum(self.batch_sizes)
+            self.batch_starts = np.concatenate([[0], self.batch_ends[:-1]])
+
+        else:
+            raise ValueError(f"batch_type {batch_type} not supported!")
+
+        log_rank_0(f"Done, time: {time.time() - start: .2f} s, total batches: {self.__len__()}")
+
+    def __getitem__(self, index: int) -> G2SBatch:
+        batch_index = index
+        batch_start = self.batch_starts[batch_index]
+        batch_end = self.batch_ends[batch_index]
+
+        data_indices = self.data_indices[batch_start:batch_end]
+
+        # collating, essentially
+        # source (graph)
+        graph_features = []
+        a_lengths = []
+
+        # ------
+        modified_data_indicies = []
+        for data_index in data_indices:
+            start, end = self.a_scopes_indices[data_index]
+            a_scope = self.a_scopes[start:end]
+            a_length = a_scope[-1][0] + a_scope[-1][1] - a_scope[0][0]
+            if a_length <= 600: modified_data_indicies.append(data_index) # hard cap on number of atoms for distance calculation
+            # if a_length <= 200: modified_data_indicies.append(data_index) # hard cap on number of atoms for distance calculation
+            # else: log_rank_0("Node length was {}".format(a_length))
+        
+        if not modified_data_indicies: return
+        modified_data_indicies.extend([min(modified_data_indicies)]*(len(data_indices)-len(modified_data_indicies))) # duplicate till full
+        assert len(modified_data_indicies) == len(data_indices)
+        # ------
+
+        # for data_index in data_indices:
+        for data_index in modified_data_indicies: 
+            start, end = self.a_scopes_indices[data_index]
+            a_scope = self.a_scopes[start:end]
+            a_length = a_scope[-1][0] + a_scope[-1][1] - a_scope[0][0]
+
+            start, end = self.b_scopes_indices[data_index]
+            b_scope = self.b_scopes[start:end]
+
+            start, end = self.a_features_indices[data_index]
+            a_feature = self.a_features[start:end]
+            a_graph = self.a_graphs[start:end]
+
+            start, end = self.b_features_indices[data_index]
+            b_feature = self.b_features[start:end]
+            b_graph = self.b_graphs[start:end]
+
+            graph_feature = (a_scope, b_scope, a_feature, b_feature, a_graph, b_graph)
+            graph_features.append(graph_feature)
+            a_lengths.append(a_length)
+
+        # # collating, essentially
+        # # source (graph)
+        # graph_features = []
+        # a_lengths = []
+        # for data_index in data_indices:
+        #     start, end = self.a_scopes_indices[data_index]
+        #     a_scope = self.a_scopes[start:end]
+        #     a_length = a_scope[-1][0] + a_scope[-1][1] - a_scope[0][0]
+
+        #     start, end = self.b_scopes_indices[data_index]
+        #     b_scope = self.b_scopes[start:end]
+
+        #     start, end = self.a_features_indices[data_index]
+        #     a_feature = self.a_features[start:end]
+        #     a_graph = self.a_graphs[start:end]
+
+        #     start, end = self.b_features_indices[data_index]
+        #     b_feature = self.b_features[start:end]
+        #     b_graph = self.b_graphs[start:end]
+
+        #     graph_feature = (a_scope, b_scope, a_feature, b_feature, a_graph, b_graph)
+        #     graph_features.append(graph_feature)
+        #     a_lengths.append(a_length)
+
+        fnode, fmess, agraph, bgraph, atom_scope, bond_scope = collate_graph_features(graph_features)
+
+        # target (seq)
+        tgt_token_ids = self.tgt_token_ids[data_indices]
+        tgt_lengths = self.tgt_lens[data_indices]
+
+        tgt_token_ids = tgt_token_ids[:, :max(tgt_lengths)]
+
+        tgt_token_ids = torch.as_tensor(tgt_token_ids, dtype=torch.long)
+        tgt_lengths = torch.tensor(tgt_lengths, dtype=torch.long)
+
+        distances = None
+        if self.args.compute_graph_distance:
+            distances = collate_graph_distances(self.args, graph_features, a_lengths, self.distance_calculator)
+
+        """
+        logging.info("--------------------src_tokens--------------------")
+        for data_index in data_indices:
+            smi = "".join(self.vocab_tokens[src_token_id] for src_token_id in self.src_token_ids[data_index])
+            logging.info(smi)
+        logging.info("--------------------distances--------------------")
+        logging.info(f"{distances}")
+        exit(0)
+        """
+
+        g2s_batch = G2SBatch(
+            fnode=fnode,
+            fmess=fmess,
+            agraph=agraph,
+            bgraph=bgraph,
+            atom_scope=atom_scope,
+            bond_scope=bond_scope,
+            tgt_token_ids=tgt_token_ids,
+            tgt_lengths=tgt_lengths,
+            distances=distances
+        )
+        # g2s_batch.log_tensor_shape()
+
+        return g2s_batch
+
+    def __len__(self):
+        return len(self.batch_sizes)
+
+
+def collate_graph_features(graph_features: List[Tuple], directed: bool = True
+                           ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor,
+                                      List[np.ndarray], List[np.ndarray]]:
+    if directed:
+        padded_features = get_atom_features_sparse(Chem.Atom("*"))
+        fnode = [np.array(padded_features)]
+        fmess = [np.zeros(shape=[1, 2 + BOND_FDIM], dtype=np.int32)]
+        agraph = [np.zeros(shape=[1, 11], dtype=np.int32)]
+        bgraph = [np.zeros(shape=[1, 11], dtype=np.int32)]
+
+        n_unique_bonds = 1
+        edge_offset = 1
+
+        atom_scope, bond_scope = [], []
+
+        for bid, graph_feature in enumerate(graph_features):
+            a_scope, b_scope, atom_features, bond_features, a_graph, b_graph = graph_feature
+
+            a_scope = a_scope.copy()
+            b_scope = b_scope.copy()
+            atom_features = atom_features.copy()
+            bond_features = bond_features.copy()
+            a_graph = a_graph.copy()
+            b_graph = b_graph.copy()
+
+            atom_offset = len(fnode)
+            bond_offset = n_unique_bonds
+            n_unique_bonds += int(bond_features.shape[0] / 2)              # This should be correct?
+
+            a_scope[:, 0] += atom_offset
+            b_scope[:, 0] += bond_offset
+            atom_scope.append(a_scope)
+            bond_scope.append(b_scope)
+
+            # node iteration is reduced to an extend
+            fnode.extend(atom_features)
+
+            # edge iteration is reduced to an append
+            bond_features[:, :2] += atom_offset
+            fmess.append(bond_features)
+
+            a_graph += edge_offset
+            a_graph[a_graph >= 999999999] = 0           # resetting padding edge to point towards edge 0
+            agraph.append(a_graph)
+
+            b_graph += edge_offset
+            b_graph[b_graph >= 999999999] = 0           # resetting padding edge to point towards edge 0
+            bgraph.append(b_graph)
+
+            edge_offset += bond_features.shape[0]
+
+        # densification
+        fnode = np.stack(fnode, axis=0)
+        fnode_one_hot = np.zeros([fnode.shape[0], sum(ATOM_FDIM)], dtype=np.float32)
+
+        for i in range(len(ATOM_FDIM) - 1):
+            fnode[:, i+1:] += ATOM_FDIM[i]          # cumsum, essentially
+
+        for i, feat in enumerate(fnode):            # Looks vectorizable?
+            # fnode_one_hot[i, feat[feat < 9999]] = 1
+            fnode_one_hot[i, feat[feat < sum(ATOM_FDIM)]] = 1
+
+        fnode = torch.as_tensor(fnode_one_hot, dtype=torch.float)
+        fmess = torch.as_tensor(np.concatenate(fmess, axis=0), dtype=torch.float)
+
+        agraph = np.concatenate(agraph, axis=0)
+        column_idx = np.argwhere(np.all(agraph[..., :] == 0, axis=0))
+        agraph = agraph[:, :column_idx[0, 0] + 1]       # drop trailing columns of 0, leaving only 1 last column of 0
+
+        bgraph = np.concatenate(bgraph, axis=0)
+        column_idx = np.argwhere(np.all(bgraph[..., :] == 0, axis=0))
+        bgraph = bgraph[:, :column_idx[0, 0] + 1]       # drop trailing columns of 0, leaving only 1 last column of 0
+
+        agraph = torch.as_tensor(agraph, dtype=torch.long)
+        bgraph = torch.as_tensor(bgraph, dtype=torch.long)
+
+    else:
+        raise NotImplementedError
+
+    return fnode, fmess, agraph, bgraph, atom_scope, bond_scope
+
+
+def collate_graph_distances(args, graph_features: List[Tuple], a_lengths: List[int],
+                            distance_calculator=None) -> torch.Tensor:
+    max_len = max(a_lengths)
+
+    distances = []
+    for bid, (graph_feature, a_length) in enumerate(zip(graph_features, a_lengths)):
+        _, _, _, bond_features, _, _ = graph_feature
+        bond_features = bond_features.copy()
+
+        # compute adjacency
+        adjacency = np.zeros((a_length, a_length), dtype=np.bool_)
+        for bond_feature in bond_features:
+            u, v = bond_feature[:2]
+            adjacency[u, v] = True
+
+        distance = distance_calculator.calculate(adjacency, a_length, max_distance=a_length)
+
+        # bucket
+        distance[(distance > 8) & (distance < 15)] = 8
+        distance[distance >= 15] = 9
+        distance[distance == 0] = 10
+
+        # reset diagonal
+        np.fill_diagonal(distance, 0)
+
+        """
+        graph_distance = distance.copy()
+
+        # compute graph distance
+        distance = adjacency.copy()
+        shortest_paths = adjacency.copy()
+        path_length = 2
+        stop_counter = 0
+        non_zeros = 0
+
+        while 0 in distance:
+            shortest_paths = np.matmul(shortest_paths, adjacency)
+            shortest_paths = path_length * (shortest_paths > 0)
+            new_distance = distance + (distance == 0) * shortest_paths
+
+            # if np.count_nonzero(new_distance) == np.count_nonzero(distance):
+            if np.count_nonzero(new_distance) <= non_zeros:
+                stop_counter += 1
+            else:
+                non_zeros = np.count_nonzero(new_distance)
+                stop_counter = 0
+
+            if args.task == "reaction_prediction" and stop_counter == 3:
+                break
+
+            distance = new_distance
+            path_length += 1
+
+        # bucket
+        distance[(distance > 8) & (distance < 15)] = 8
+        distance[distance >= 15] = 9
+        distance[distance == 0] = 10            # different molecules
+
+        # reset diagonal
+        np.fill_diagonal(distance, 0)
+        """
+
+        # padding
+        # padded_distance = np.ones((max_len, max_len), dtype=np.uint8) * 11
+        padded_distance = np.ones((max_len, max_len), dtype=np.uint8) * (args.rel_pos_buckets + 1)
+        # padded_distance[:a_length, :a_length] = graph_distance
+        padded_distance[:a_length, :a_length] = distance
+
+        # assert np.array_equal(padded_distance[:a_length, :a_length], distance), \
+        #     f"padded_distance:\n{padded_distance[:a_length, :a_length]}\n" \
+        #     f"distance:\n{distance}"
+
+        distances.append(padded_distance)
+
+    distances = np.stack(distances)
+    distances = torch.as_tensor(distances, dtype=torch.long)
+
+    return distances

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/graph2smiles_runtime/utils/parsing.py

@@ -0,0 +1,120 @@
+from utils.train_utils import log_rank_0
+
+
+def log_args(args, phase: str):
+    log_rank_0(f"Logging {phase} arguments")
+    for k, v in vars(args).items():
+        log_rank_0(f"**** {k} = *{v}*")
+
+
+def add_common_args(parser):
+    group = parser.add_argument_group("Meta")
+    group.add_argument("--model", help="Model architecture",
+                       choices=["graph2smiles"], type=str, default="graph2smiles")
+    group.add_argument("--data_name", help="Data name", type=str, default="")
+    group.add_argument("--task", help="Task", choices=["reaction_prediction", "retrosynthesis", "autoencoding"],
+                       type=str, default="reaction_prediction")
+    group.add_argument("--seed", help="Random seed", type=int, default=42)
+    group.add_argument("--max_src_len", help="Max source length", type=int, default=512)
+    group.add_argument("--max_tgt_len", help="Max target length", type=int, default=512)
+    group.add_argument("--num_cores", help="No. of workers", type=int, default=1)
+    group.add_argument("--verbose", help="Whether to enable verbose debugging", action="store_true")
+
+    group = parser.add_argument_group("Paths")
+    group.add_argument("--log_file", help="Preprocess log file", type=str, default="")
+    group.add_argument("--processed_data_path", help="Path for saving preprocessed outputs",
+                       type=str, default="")
+    group.add_argument("--model_path", help="Path for saving checkpoints", type=str, default="")
+    group.add_argument("--test_output_path", help="Path for saving test outputs", type=str, default="")
+
+
+def add_preprocess_args(parser):
+    group = parser.add_argument_group("Preprocessing options")
+    # data paths
+    group.add_argument("--train_file", help="Train file", type=str, default="")
+    group.add_argument("--val_file", help="Validation file", type=str, default="")
+    group.add_argument("--test_file", help="Test file", type=str, default="")
+
+
+def add_train_args(parser):
+    group = parser.add_argument_group("Training options")
+    # file paths
+    group.add_argument("--load_from", help="Checkpoint to load", type=str, default="")
+    # model params
+    group.add_argument("--embed_size", help="Decoder embedding size", type=int, default=256)
+    group.add_argument("--share_embeddings", help="Whether to share encoder/decoder embeddings", action="store_true")
+    group.add_argument("--mask_rel_chirality", help="Whether to mask relative chirality", type=int, default=0)
+    group.add_argument("--shared_attention_layer", help="Whether to share attention layer", type=int, default=0)
+    # latent modeling
+    group.add_argument("--n_latent", help="Latent modeling mode or number of latent class", type=str, default="1")
+    # -------------- mpn encoder ---------------
+    group.add_argument("--mpn_type", help="Type of MPN", type=str,
+                       choices=["dgcn", "dgat"], default="dgcn")
+    group.add_argument("--encoder_num_layers", help="No. of layers in transformer/mpn encoder", type=int, default=4)
+    group.add_argument("--dgat_attn_heads", help="DGAT no. of attention heads", type=int, default=8)
+    group.add_argument("--encoder_hidden_size", help="Encoder hidden size", type=int, default=256)
+    group.add_argument("--encoder_attn_heads", help="Encoder no. of attention heads", type=int, default=8)
+    group.add_argument("--encoder_filter_size", help="Encoder filter size", type=int, default=2048)
+    group.add_argument("--encoder_norm", help="Encoder norm", type=str, default="none")
+    group.add_argument("--encoder_skip_connection", help="Encoder skip connection", type=str, default="none")
+    group.add_argument("--encoder_positional_encoding", help="Encoder positional encoding", type=str, default="")
+    group.add_argument("--encoder_emb_scale", help="How to scale encoder embedding", type=str, default="")
+    # -------------- attention encoder ---------------
+    group.add_argument("--compute_graph_distance", help="Whether to compute graph distance", action="store_true")
+    group.add_argument("--attn_enc_num_layers", help="No. of layers", type=int, default=4)
+    group.add_argument("--attn_enc_hidden_size", help="Hidden size", type=int, default=256)
+    group.add_argument("--attn_enc_heads", help="Hidden size", type=int, default=8)
+    group.add_argument("--attn_enc_filter_size", help="Filter size", type=int, default=2048)
+    group.add_argument("--rel_pos", help="type of rel. pos.", type=str, default="none")
+    group.add_argument("--rel_pos_buckets", help="No. of relative position buckets", type=int, default=10)
+    # -------------- Transformer decoder ---------------
+    group.add_argument("--decoder_num_layers", help="No. of layers in transformer decoder", type=int, default=4)
+    group.add_argument("--decoder_hidden_size", help="Decoder hidden size", type=int, default=256)
+    group.add_argument("--decoder_attn_heads", help="Decoder no. of attention heads", type=int, default=8)
+    group.add_argument("--decoder_filter_size", help="Decoder filter size", type=int, default=2048)
+    group.add_argument("--dropout", help="Hidden dropout", type=float, default=0.0)
+    group.add_argument("--attn_dropout", help="Attention dropout", type=float, default=0.0)
+    group.add_argument("--max_relative_positions", help="Max relative positions", type=int, default=0)
+    # training params
+    group.add_argument('--local_rank', type=int, default=-1, metavar='N', help='Local process rank')
+    group.add_argument("--enable_amp", help="Whether to enable mixed precision training", action="store_true")
+    group.add_argument("--resume", help="Whether to resume training", action="store_true")
+    group.add_argument("--backend", help="Backend for DDP", type=str, default="gloo")
+    group.add_argument("--epoch", help="Number of training epochs", type=int, default=300)
+    group.add_argument("--max_steps", help="Number of max total steps", type=int, default=1000000)
+    group.add_argument("--warmup_steps", help="Number of warmup steps", type=int, default=8000)
+    group.add_argument("--lr", help="Learning rate", type=float, default=0.0)
+    group.add_argument("--beta1", help="Adam beta 1", type=float, default=0.9)
+    group.add_argument("--beta2", help="Adam beta 2", type=float, default=0.998)
+    group.add_argument("--eps", help="Adam epsilon", type=float, default=1e-9)
+    group.add_argument("--weight_decay", help="Adam weight decay", type=float, default=1e-2)
+    group.add_argument("--clip_norm", help="Max norm for gradient clipping", type=float, default=20.0)
+    group.add_argument("--batch_type", help="batch type", type=str, default="tokens")
+    group.add_argument("--train_batch_size", help="Batch size for train", type=int, default=4096)
+    group.add_argument("--val_batch_size", help="Batch size for valid", type=int, default=4096)
+    group.add_argument("--accumulation_count", help="No. of batches for gradient accumulation", type=int, default=1)
+    group.add_argument("--log_iter", help="No. of steps per logging", type=int, default=100)
+    group.add_argument("--eval_iter", help="No. of steps per evaluation", type=int, default=100)
+    group.add_argument("--save_iter", help="No. of steps per saving", type=int, default=100)
+    # debug params
+    group.add_argument("--do_profile", help="Whether to do profiling", action="store_true")
+    group.add_argument("--record_shapes", help="Whether to record tensor shapes for profiling", action="store_true")
+
+    return parser
+
+
+def add_predict_args(parser):
+    group = parser.add_argument_group("Prediction options")
+    group.add_argument("--do_validate", help="Whether to do validation", action="store_true")
+    group.add_argument("--do_predict", help="Whether to do prediction", action="store_true")
+    group.add_argument("--do_score", help="Whether to score predictions", action="store_true")
+    group.add_argument("--checkpoint_step_start", help="First checkpoint step", type=int)
+    group.add_argument("--checkpoint_step_end", help="Last checkpoint step", type=int)
+    group.add_argument("--predict_batch_size", help="Batch size for prediction", type=int, default=4096)
+    # decoding params
+    group.add_argument("--result_file", help="Result file", type=str, default="")
+    group.add_argument("--beam_size", help="Beam size for decoding", type=int, default=0)
+    group.add_argument("--n_best", help="Number of best results to be retained", type=int, default=10)
+    group.add_argument("--temperature", help="Beam search temperature", type=float, default=1.0)
+    group.add_argument("--predict_min_len", help="Min length for prediction", type=int, default=1)
+    group.add_argument("--predict_max_len", help="Max length for prediction", type=int, default=512)

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/graph2smiles_runtime/utils/preprocess_utils.py

@@ -0,0 +1,153 @@
+import logging
+import networkx as nx
+import numpy as np
+import os
+import re
+from rdkit import Chem
+from typing import Dict, List, Tuple
+from utils.chem_utils import get_atom_features_sparse, get_bond_features
+from utils.rxn_graphs import RxnGraph
+from utils.train_utils import log_rank_0
+
+
+def smi_tokenizer(smi: str):
+    """Tokenize a SMILES molecule or reaction, adapted from https://github.com/pschwllr/MolecularTransformer"""
+    pattern = "(\[[^\]]+]|Br?|Cl?|N|O|S|P|F|I|b|c|n|o|s|p|\(|\)|\.|=|#|-|\+|\\\\|\/|:|~|@|\?|>|\*|\$|\%[0-9]{2}|[0-9])"
+    regex = re.compile(pattern)
+    tokens = [token for token in regex.findall(smi)]
+    assert smi == "".join(tokens)
+
+    return " ".join(tokens)
+
+
+def get_token_ids(tokens: list, vocab: Dict[str, int], max_len: int) -> Tuple[List, int]:
+    token_ids = []
+    token_ids.extend([vocab[token] for token in tokens])
+    token_ids = token_ids[:max_len-1]
+    token_ids.append(vocab["_EOS"])
+
+    lens = len(token_ids)
+    while len(token_ids) < max_len:
+        token_ids.append(vocab["_PAD"])
+
+    return token_ids, lens
+
+
+def get_graph_from_smiles(smi: str):
+    mol = Chem.MolFromSmiles(smi)
+    if mol is None or mol.GetNumBonds() == 0:
+        mol = Chem.MolFromSmiles("CC")      # hardcode to ignore
+    rxn_graph = RxnGraph(reac_mol=mol)
+
+    return rxn_graph
+
+
+def get_graph_features_from_smi(_args):
+    i, smi = _args
+    assert isinstance(smi, str)
+    if i > 0 and i % 10000 == 0:
+        logging.info(f"Processing {i}th SMILES")
+
+    atom_features = []
+    bond_features = []
+    edge_dict = {}
+
+    if not smi.strip():
+        smi = "CC"          # hardcode to ignore
+
+    smi = "".join(smi.split())
+    graph = get_graph_from_smiles(smi).reac_mol
+
+    mol = graph.mol
+    assert mol.GetNumAtoms() == len(graph.G_dir)
+
+    G = nx.convert_node_labels_to_integers(graph.G_dir, first_label=0)
+
+    # node iteration to get sparse atom features
+    for v, attr in G.nodes(data="label"):
+        atom_feat = get_atom_features_sparse(mol.GetAtomWithIdx(v))
+        atom_features.append(atom_feat)
+
+    a_graphs = [[] for _ in range(len(atom_features))]
+
+    # edge iteration to get (dense) bond features
+    for u, v, attr in G.edges(data='label'):
+        bond_feat = get_bond_features(mol.GetBondBetweenAtoms(u, v))
+        bond_feat = [u, v] + bond_feat
+        bond_features.append(bond_feat)
+
+        eid = len(edge_dict)
+        edge_dict[(u, v)] = eid
+        a_graphs[v].append(eid)
+
+    b_graphs = [[] for _ in range(len(bond_features))]
+
+    # second edge iteration to get neighboring edges (after edge_dict is updated fully)
+    for bond_feat in bond_features:
+        u, v = bond_feat[:2]
+        eid = edge_dict[(u, v)]
+
+        for w in G.predecessors(u):
+            if not w == v:
+                b_graphs[eid].append(edge_dict[(w, u)])
+
+    # padding
+    for a_graph in a_graphs:
+        while len(a_graph) < 11:            # OH MY GOODNESS... Fe can be bonded to 10...
+            a_graph.append(1e9)
+
+    for b_graph in b_graphs:
+        while len(b_graph) < 11:            # OH MY GOODNESS... Fe can be bonded to 10...
+            b_graph.append(1e9)
+
+    a_scopes = np.array(graph.atom_scope, dtype=np.int32)
+    a_scopes_lens = a_scopes.shape[0]
+    b_scopes = np.array(graph.bond_scope, dtype=np.int32)
+    b_scopes_lens = b_scopes.shape[0]
+    a_features = np.array(atom_features, dtype=np.int32)
+    a_features_lens = a_features.shape[0]
+    b_features = np.array(bond_features, dtype=np.int32)
+    b_features_lens = b_features.shape[0]
+    a_graphs = np.array(a_graphs, dtype=np.int32)
+    b_graphs = np.array(b_graphs, dtype=np.int32)
+
+    return a_scopes, a_scopes_lens, b_scopes, b_scopes_lens, \
+        a_features, a_features_lens, b_features, b_features_lens, a_graphs, b_graphs
+
+
+def make_vocab(args):
+    logging.info(f"Making vocab")
+    vocab = {}
+
+    for phase in ["train", "val", "test"]:
+        for fn in [
+            os.path.join(args.processed_data_path, f"src-{phase}.txt"),
+            os.path.join(args.processed_data_path, f"tgt-{phase}.txt")
+        ]:
+            with open(fn, "r") as f:
+                for line in f:
+                    tokens = line.strip().split()
+                    for token in tokens:
+                        if token in vocab:
+                            vocab[token] += 1
+                        else:
+                            vocab[token] = 1
+
+    vocab_file = os.path.join(args.processed_data_path, "vocab.txt")
+    logging.info(f"Saving vocab into {vocab_file}")
+    with open(vocab_file, "w") as of:
+        of.write("_PAD\n_UNK\n_SOS\n_EOS\n")
+        for token, count in vocab.items():
+            of.write(f"{token}\t{count}\n")
+
+
+def load_vocab(args) -> Dict[str, int]:
+    vocab_file = os.path.join(args.processed_data_path, "vocab.txt")
+    log_rank_0(f"Loading vocab from {vocab_file}")
+    vocab = {}
+    with open(vocab_file, "r") as f:
+        for i, line in enumerate(f):
+            token = line.strip().split("\t")[0]
+            vocab[token] = i
+
+    return vocab

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/graph2smiles_runtime/utils/rxn_graphs.py

@@ -0,0 +1,196 @@
+import networkx as nx
+from utils.chem_utils import BOND_TYPES
+from rdkit import Chem
+from typing import List, Tuple, Union
+
+
+def get_sub_mol(mol, sub_atoms):
+    new_mol = Chem.RWMol()
+    atom_map = {}
+    for idx in sub_atoms:
+        atom = mol.GetAtomWithIdx(idx)
+        atom_map[idx] = new_mol.AddAtom(atom)
+
+    sub_atoms = set(sub_atoms)
+    for idx in sub_atoms:
+        a = mol.GetAtomWithIdx(idx)
+        for b in a.GetNeighbors():
+            if b.GetIdx() not in sub_atoms:
+                continue
+            bond = mol.GetBondBetweenAtoms(a.GetIdx(), b.GetIdx())
+            bt = bond.GetBondType()
+            if a.GetIdx() < b.GetIdx():  # each bond is enumerated twice
+                new_mol.AddBond(atom_map[a.GetIdx()], atom_map[b.GetIdx()], bt)
+
+    return new_mol.GetMol()
+
+
+class RxnGraph:
+    """
+    RxnGraph is an abstract class for storing all elements of a reaction, like
+    reactants, products and fragments. The edits associated with the reaction
+    are also captured in edit labels. One can also use h_labels, which keep track
+    of atoms with hydrogen changes. For reactions with multiple edits, a done
+    label is also added to account for termination of edits.
+    """
+
+    def __init__(self,
+                 prod_mol: Chem.Mol = None,
+                 frag_mol: Chem.Mol = None,
+                 reac_mol: Chem.Mol = None,
+                 rxn_class: int = None) -> None:
+        """
+        Parameters
+        ----------
+        prod_mol: Chem.Mol,
+            Product molecule
+        frag_mol: Chem.Mol, default None
+            Fragment molecule(s)
+        reac_mol: Chem.Mol, default None
+            Reactant molecule(s)
+        rxn_class: int, default None,
+            Reaction class for this reaction.
+        """
+        if prod_mol is not None:
+            self.prod_mol = RxnElement(mol=prod_mol, rxn_class=rxn_class)
+        if frag_mol is not None:
+            self.frag_mol = MultiElement(mol=frag_mol, rxn_class=rxn_class)
+        if reac_mol is not None:
+            self.reac_mol = MultiElement(mol=reac_mol, rxn_class=rxn_class)
+        self.rxn_class = rxn_class
+
+    def get_attributes(self, mol_attrs: Tuple = ('prod_mol', 'frag_mol', 'reac_mol')) -> Tuple:
+        """
+        Returns the different attributes associated with the reaction graph.
+
+        Parameters
+        ----------
+        mol_attrs: Tuple,
+            Molecule objects to return
+        """
+        return tuple(getattr(self, attr) for attr in mol_attrs if hasattr(self, attr))
+
+
+class RxnElement:
+    """
+    RxnElement is an abstract class for dealing with single molecule. The graph
+    and corresponding molecule attributes are built for the molecule. The constructor
+    accepts only mol objects, sidestepping the use of SMILES string which may always
+    not be achievable, especially for a unkekulizable molecule.
+    """
+
+    def __init__(self, mol: Chem.Mol, rxn_class: int = None) -> None:
+        """
+        Parameters
+        ----------
+        mol: Chem.Mol,
+            Molecule
+        rxn_class: int, default None,
+            Reaction class for this reaction.
+        """
+        self.mol = mol
+        self.rxn_class = rxn_class
+        self._build_mol()
+        self._build_graph()
+
+    def _build_mol(self) -> None:
+        """Builds the molecule attributes."""
+        self.num_atoms = self.mol.GetNumAtoms()
+        self.num_bonds = self.mol.GetNumBonds()
+        self.amap_to_idx = {atom.GetAtomMapNum(): atom.GetIdx()
+                            for atom in self.mol.GetAtoms()}
+        self.idx_to_amap = {value: key for key, value in self.amap_to_idx.items()}
+
+    def _build_graph(self) -> None:
+        """Builds the graph attributes."""
+        self.G_undir = nx.Graph(Chem.rdmolops.GetAdjacencyMatrix(self.mol))
+        self.G_dir = nx.DiGraph(Chem.rdmolops.GetAdjacencyMatrix(self.mol))
+
+        for atom in self.mol.GetAtoms():
+            self.G_undir.nodes[atom.GetIdx()]['label'] = atom.GetSymbol()
+            self.G_dir.nodes[atom.GetIdx()]['label'] = atom.GetSymbol()
+
+        for bond in self.mol.GetBonds():
+            a1 = bond.GetBeginAtom().GetIdx()
+            a2 = bond.GetEndAtom().GetIdx()
+            btype = BOND_TYPES.index(bond.GetBondType())
+            self.G_undir[a1][a2]['label'] = btype
+            self.G_dir[a1][a2]['label'] = btype
+            self.G_dir[a2][a1]['label'] = btype
+
+        self.atom_scope = (0, self.num_atoms)
+        self.bond_scope = (0, self.num_bonds)
+
+    def update_atom_scope(self, offset: int) -> Union[List, Tuple]:
+        """Updates the atom indices by the offset.
+
+        Parameters
+        ----------
+        offset: int,
+            Offset to apply
+        """
+        # Note that the self. reference to atom_scope is dropped to keep self.atom_scope non-dynamic
+        if isinstance(self.atom_scope, list):
+            atom_scope = [(st + offset, le) for st, le in self.atom_scope]
+        else:
+            st, le = self.atom_scope
+            atom_scope = (st + offset, le)
+
+        return atom_scope
+
+    def update_bond_scope(self, offset: int) -> Union[List, Tuple]:
+        """Updates the bond indices by the offset.
+
+        Parameters
+        ----------
+        offset: int,
+            Offset to apply
+        """
+        # Note that the self. reference to bond_scope is dropped to keep self.bond_scope non-dynamic
+        if isinstance(self.bond_scope, list):
+            bond_scope = [(st + offset, le) for st, le in self.bond_scope]
+        else:
+            st, le = self.bond_scope
+            bond_scope = (st + offset, le)
+
+        return bond_scope
+
+
+class MultiElement(RxnElement):
+    """
+    MultiElement is an abstract class for dealing with multiple molecules. The graph
+    is built with all molecules, but different molecules and their sizes are stored.
+    The constructor accepts only mol objects, sidestepping the use of SMILES string
+    which may always not be achievable, especially for an invalid intermediates.
+    """
+
+    def _build_graph(self) -> None:
+        """Builds the graph attributes."""
+        self.G_undir = nx.Graph(Chem.rdmolops.GetAdjacencyMatrix(self.mol))
+        self.G_dir = nx.DiGraph(Chem.rdmolops.GetAdjacencyMatrix(self.mol))
+
+        for atom in self.mol.GetAtoms():
+            self.G_undir.nodes[atom.GetIdx()]['label'] = atom.GetSymbol()
+            self.G_dir.nodes[atom.GetIdx()]['label'] = atom.GetSymbol()
+
+        for bond in self.mol.GetBonds():
+            a1 = bond.GetBeginAtom().GetIdx()
+            a2 = bond.GetEndAtom().GetIdx()
+            btype = BOND_TYPES.index(bond.GetBondType())
+            self.G_undir[a1][a2]['label'] = btype
+            self.G_dir[a1][a2]['label'] = btype
+            self.G_dir[a2][a1]['label'] = btype
+
+        frag_indices = [c for c in nx.strongly_connected_components(self.G_dir)]
+        self.mols = [get_sub_mol(self.mol, sub_atoms) for sub_atoms in frag_indices]
+
+        atom_start = 0
+        bond_start = 0
+        self.atom_scope = []
+        self.bond_scope = []
+
+        for mol in self.mols:
+            self.atom_scope.append((atom_start, mol.GetNumAtoms()))
+            self.bond_scope.append((bond_start, mol.GetNumBonds()))
+            atom_start += mol.GetNumAtoms()
+            bond_start += mol.GetNumBonds()

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/graph2smiles_runtime/utils/train_utils.py

@@ -0,0 +1,111 @@
+import logging
+import math
+import numpy as np
+import os
+import random
+import sys
+import torch
+import torch.nn as nn
+from datetime import datetime
+from rdkit import RDLogger
+from torch.optim.lr_scheduler import _LRScheduler
+
+
+def log_rank_0(message):
+    if torch.distributed.is_initialized():
+        if torch.distributed.get_rank() == 0:
+            logging.info(message)
+            sys.stdout.flush()
+    else:
+        logging.info(message)
+        sys.stdout.flush()
+
+
+def param_count(model: nn.Module) -> int:
+    return sum(param.numel() for param in model.parameters() if param.requires_grad)
+
+
+def param_norm(m):
+    return math.sqrt(sum([p.norm().item() ** 2 for p in m.parameters()]))
+
+
+def grad_norm(m):
+    return math.sqrt(sum([p.grad.norm().item() ** 2 for p in m.parameters() if p.grad is not None]))
+
+
+def get_lr(optimizer):
+    for param_group in optimizer.param_groups:
+        return param_group["lr"]
+
+
+def set_seed(seed):
+    random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.benchmark = False
+    torch.backends.cudnn.deterministic = True
+
+
+def setup_logger(args, warning_off: bool = False):
+    if warning_off:
+        RDLogger.DisableLog("rdApp.*")
+    else:
+        RDLogger.DisableLog("rdApp.warning")
+
+    os.makedirs(f"./logs/{args.data_name}", exist_ok=True)
+    dt = datetime.strftime(datetime.now(), "%y%m%d-%H%Mh")
+
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+    fh = logging.FileHandler(f"./logs/{args.data_name}/{args.log_file}.{dt}")
+    sh = logging.StreamHandler(sys.stdout)
+    fh.setLevel(logging.INFO)
+    sh.setLevel(logging.INFO)
+    logger.addHandler(fh)
+    logger.addHandler(sh)
+
+    return logger
+
+
+def log_tensor(tensor, tensor_name: str, shape_only=False):
+    log_rank_0(f"--------------------------{tensor_name}--------------------------")
+    if not shape_only:
+        log_rank_0(tensor)
+    if isinstance(tensor, torch.Tensor):
+        log_rank_0(tensor.shape)
+    elif isinstance(tensor, np.ndarray):
+        log_rank_0(tensor.shape)
+    elif isinstance(tensor, list):
+        try:
+            for item in tensor:
+                log_rank_0(item.shape)
+        except Exception as e:
+            log_rank_0(f"Error: {e}")
+            log_rank_0("List items are not tensors, skip shape logging.")
+
+
+class NoamLR(_LRScheduler):
+    """
+    Adapted from https://github.com/tugstugi/pytorch-saltnet/blob/master/utils/lr_scheduler.py
+
+    Implements the Noam Learning rate schedule. This corresponds to increasing the learning rate
+    linearly for the first ``warmup_steps`` training steps, and decreasing it thereafter proportionally
+    to the inverse square root of the step number, scaled by the inverse square root of the
+    dimensionality of the model. Time will tell if this is just madness or it's actually important.
+    Parameters
+    ----------
+    warmup_steps: ``int``, required.
+        The number of steps to linearly increase the learning rate.
+    """
+    def __init__(self, optimizer, model_size, warmup_steps):
+        self.model_size = model_size
+        self.warmup_steps = warmup_steps
+        super().__init__(optimizer)
+
+    def get_lr(self):
+        step = max(1, self._step_count)
+        scale = self.model_size ** (-0.5) * min(step ** (-0.5), step * self.warmup_steps**(-1.5))
+
+        return [base_lr * scale for base_lr in self.base_lrs]

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/mar_files/handler.py

@@ -0,0 +1,278 @@
+import glob
+import numpy as np
+import time
+import torch
+import zipfile
+import numpy as np
+from rdkit import Chem
+from multiprocessing import Pool
+from typing import Any, Dict, List
+
+
+class G2SHandler:
+    """Graph2SMILES Handler for torchserve"""
+
+    def __init__(self):
+        self._context = None
+        self.manifest = None
+        self.initialized = False
+
+        self.args = None
+        self.device = None
+        self.model = None
+        self.vocab = None
+        self.vocab_tokens = None
+        self.distance_calculator = None
+        self.p = None
+
+    def overwrite_default_args(self):
+        # self.args.load_from = "model.400000_39.pt"
+        self.args.vocab_file = "vocab.txt"
+        # self.args.mask_rel_chirality = 1
+        self.args.mask_rel_chirality = 0
+        self.args.predict_batch_size = 16384
+        self.args.beam_size = 30
+        self.args.n_best = 30
+        self.args.temperature = 1.0
+        self.args.predict_min_len = 1
+        self.args.predict_max_len = 512
+        self.args.device = self.device
+
+    def initialize(self, context):
+        self._context = context
+        self.manifest = context.manifest
+
+        properties = context.system_properties
+        model_dir = properties.get("model_dir")
+        print(glob.glob(f"{model_dir}/*"))
+        self.device = torch.device("cuda:" + str(properties.get("gpu_id")) if torch.cuda.is_available() else "cpu")
+
+        with zipfile.ZipFile(model_dir + '/models.zip', 'r') as zip_ref:
+            zip_ref.extractall(model_dir)
+        with zipfile.ZipFile(model_dir + '/utils.zip', 'r') as zip_ref:
+            zip_ref.extractall(model_dir)
+
+        from train import get_model
+        from models.graph2smiles import Graph2SMILES
+        from predict import get_predict_parser
+        from utils import parsing
+        from utils.ctypes_calculator import DistanceCalculator
+        from utils.data_utils import load_vocab
+
+        predict_parser = get_predict_parser()
+        self.args, _ = predict_parser.parse_known_args()
+        self.overwrite_default_args()
+
+        checkpoint = model_dir + "/model.pt"
+        state = torch.load(checkpoint, map_location=self.device)
+        pretrain_args = state["args"]
+        pretrain_args.load_from = None
+        pretrain_state_dict = state["state_dict"]
+
+        # for backward compatibility
+        if not hasattr(pretrain_args, "shared_attention_layer"):
+            pretrain_args.shared_attention_layer = 0
+        if not hasattr(pretrain_args, "n_latent"):
+            pretrain_args.n_latent = 1
+        # pretrain_args.rel_pos_buckets -= 1
+        pretrain_args.local_rank = -1
+        # parsing.log_args(pretrain_args, phase="pretrained")
+
+        model_class = Graph2SMILES
+
+        self.args.processed_data_path = model_dir
+        self.vocab = load_vocab(self.args)
+        self.vocab_tokens = [k for k, v in sorted(self.vocab.items(), key=lambda tup: tup[1])]
+
+        model, state = get_model(pretrain_args, model_class, self.vocab, self.device)
+        # logging.info(model)
+        if hasattr(model, "module"):
+            model = model.module  # unwrap DDP model to enable accessing model func directly
+
+        pretrain_state_dict = {k.replace("module.", ""): v for k, v in pretrain_state_dict.items()}
+        model.load_state_dict(pretrain_state_dict)
+        print(f"Loaded pretrained state_dict from {checkpoint}")
+        model.eval()
+        self.model = model
+
+        self.distance_calculator = DistanceCalculator()
+        self.p = Pool()
+
+        self.initialized = True
+
+    def preprocess(self, data: List):
+        from utils.data_utils import canonicalize_smiles, collate_graph_distances, \
+            collate_graph_features, G2SBatch, len2idx
+        from utils.preprocess_utils import get_graph_features_from_smi
+
+        # print(data)
+        canonical_smiles = [canonicalize_smiles(smi) for smi in data[0]["body"]["smiles"]]
+
+        # ----------<adapted from preprocess.py>----------
+        start = time.time()
+        graph_features_and_lengths = self.p.imap(
+            get_graph_features_from_smi, enumerate(canonical_smiles)
+        )
+        graph_features_and_lengths = list(graph_features_and_lengths)
+        print(f"Done graph featurization, time: {time.time() - start}. Collating and saving...")
+        a_scopes, a_scopes_lens, b_scopes, b_scopes_lens, a_features, a_features_lens, \
+            b_features, b_features_lens, a_graphs, b_graphs = zip(*graph_features_and_lengths)
+
+        a_scopes = np.concatenate(a_scopes, axis=0)
+        b_scopes = np.concatenate(b_scopes, axis=0)
+        a_features = np.concatenate(a_features, axis=0)
+        b_features = np.concatenate(b_features, axis=0)
+        a_graphs = np.concatenate(a_graphs, axis=0)
+        b_graphs = np.concatenate(b_graphs, axis=0)
+
+        a_scopes_lens = np.array(a_scopes_lens, dtype=np.int32)
+        b_scopes_lens = np.array(b_scopes_lens, dtype=np.int32)
+        a_features_lens = np.array(a_features_lens, dtype=np.int32)
+        b_features_lens = np.array(b_features_lens, dtype=np.int32)
+        # ----------</adapted from preprocess.py>----------
+
+        # ----------<adapted from data_utils.G2SDataset.__init__()>----------
+        if self.args.mask_rel_chirality == 1:
+            a_features[:, 6] = 2
+
+        a_scopes_indices = len2idx(a_scopes_lens)
+        b_scopes_indices = len2idx(b_scopes_lens)
+        a_features_indices = len2idx(a_features_lens)
+        b_features_indices = len2idx(b_features_lens)
+
+        del a_scopes_lens, b_scopes_lens, a_features_lens, b_features_lens
+        # ----------</adapted from data_utils.G2SDataset.__init__()>----------
+
+        # ----------<adapted from data_utils.G2SDataset.batch()>----------
+        # batching takes trivial time
+        batch_sizes = []
+
+        sample_size = 0
+        max_batch_src_len = 0
+
+        for smi in canonical_smiles:
+            src_len = len(smi)
+            max_batch_src_len = max(src_len, max_batch_src_len)
+            if max_batch_src_len * (sample_size + 1) <= self.args.predict_batch_size:
+                sample_size += 1
+            else:
+                batch_sizes.append(sample_size)
+                sample_size = 1
+                max_batch_src_len = src_len
+
+        # lastly
+        batch_sizes.append(sample_size)
+        batch_sizes = np.array(batch_sizes)
+        assert np.sum(batch_sizes) == len(canonical_smiles), \
+            f"Size mismatch! Data size: {len(canonical_smiles)}, sum batch sizes: {np.sum(batch_sizes)}"
+
+        batch_ends = np.cumsum(batch_sizes)
+        batch_starts = np.concatenate([[0], batch_ends[:-1]])
+        # ----------</adapted from data_utils.G2SDataset.batch()>----------
+
+        # ----------<adapted from data_utils.G2SDataset.__getitem__()>----------
+        g2s_batches = []
+        for batch_start, batch_end in zip(batch_starts, batch_ends):
+            data_indices = np.arange(batch_start, batch_end)
+            graph_features = []
+            a_lengths = []
+            for data_index in data_indices:
+                start, end = a_scopes_indices[data_index]
+                a_scope = a_scopes[start:end]
+                a_length = a_scope[-1][0] + a_scope[-1][1] - a_scope[0][0]
+
+                start, end = b_scopes_indices[data_index]
+                b_scope = b_scopes[start:end]
+
+                start, end = a_features_indices[data_index]
+                a_feature = a_features[start:end]
+                a_graph = a_graphs[start:end]
+
+                start, end = b_features_indices[data_index]
+                b_feature = b_features[start:end]
+                b_graph = b_graphs[start:end]
+
+                graph_feature = (a_scope, b_scope, a_feature, b_feature, a_graph, b_graph)
+                graph_features.append(graph_feature)
+                a_lengths.append(a_length)
+
+            fnode, fmess, agraph, bgraph, atom_scope, bond_scope = collate_graph_features(graph_features)
+            distances = collate_graph_distances(self.args, graph_features, a_lengths, self.distance_calculator)
+
+            g2s_batch = G2SBatch(
+                fnode=fnode,
+                fmess=fmess,
+                agraph=agraph,
+                bgraph=bgraph,
+                atom_scope=atom_scope,
+                bond_scope=bond_scope,
+                tgt_token_ids=torch.tensor([0]),
+                tgt_lengths=torch.tensor(a_lengths),
+                distances=distances
+            )
+            g2s_batches.append(g2s_batch)
+        # ----------</adapted from data_utils.G2SDataset.__getitem__()>----------
+
+        return g2s_batches
+
+    def inference(self, input, data: List) -> List[Dict[str, Any]]:
+        # adapted from predict.get_predictions()
+
+        from utils.data_utils import canonicalize_smiles
+        canonical_smiles = [canonicalize_smiles(smi) for smi in input[0]["body"]["smiles"]]
+
+        results = []
+
+        with torch.no_grad():
+            for test_idx, test_batch in enumerate(data):
+                test_batch.to(self.device)
+                batch_predictions = self.model.predict_step(
+                    reaction_batch=test_batch,
+                    batch_size=test_batch.size,
+                    beam_size=self.args.beam_size,
+                    n_best=self.args.n_best,
+                    temperature=self.args.temperature,
+                    min_length=self.args.predict_min_len,
+                    max_length=self.args.predict_max_len
+                )
+
+                for target, predictions, scores in zip(canonical_smiles, batch_predictions["predictions"], batch_predictions["scores"]):
+                    valid_product_scores = {}
+                    for prediction, score in zip(predictions, scores):
+                        predicted_idx = prediction.detach().cpu().numpy()
+                        score = score.item()
+                        predicted_tokens = [self.vocab_tokens[idx] for idx in predicted_idx[:-1]]
+                        smi = "".join(predicted_tokens)
+                        product = canonicalize_smiles(smi, trim=False, suppress_warning=True)
+                        if not product:
+                            continue
+                        else:
+                            if Chem.MolFromSmiles(target).GetNumAtoms() - Chem.MolFromSmiles(product).GetNumAtoms() > 4:
+                                continue
+                            if valid_product_scores.get(product) is None:
+                                valid_product_scores[product] = np.exp(score)
+                            else: 
+                                valid_product_scores[product] += np.exp(score)
+                    valid_product_scores = dict(sorted(valid_product_scores.items(), key=lambda x: x[1], reverse=True))
+                    valid_products = list(valid_product_scores.keys())
+                    valid_scores = list(valid_product_scores.values())
+                    result = {
+                        "products": valid_products,
+                        "scores": valid_scores
+                    }
+                    results.append(result)
+
+        return results
+
+    def postprocess(self, data: List[Dict[str, Any]]) -> List[List[Dict[str, Any]]]:
+        return [data]
+
+    def handle(self, data, context) -> List[List[Dict[str, Any]]]:
+        self._context = context
+
+        output = self.preprocess(data)
+        output = self.inference(data, output)
+        output = self.postprocess(output)
+        # print(output)
+
+        return output

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/mar_files/predict.py

@@ -0,0 +1,254 @@
+import argparse
+import datetime
+import glob
+import numpy as np
+import os
+import sys
+import time
+import torch
+import torch.distributed as dist
+from models.graph2smiles import Graph2SMILES
+from torch.utils.data import DataLoader, SequentialSampler
+from torch.utils.data.distributed import DistributedSampler
+from train import get_model
+from utils import parsing
+from utils.data_utils import canonicalize_smiles, load_vocab, G2SDataset
+from utils.train_utils import log_tensor, log_rank_0, param_count, set_seed, setup_logger
+
+
+def get_predict_parser():
+    parser = argparse.ArgumentParser("predict")
+    parsing.add_common_args(parser)
+    parsing.add_preprocess_args(parser)
+    parsing.add_train_args(parser)
+    parsing.add_predict_args(parser)
+
+    return parser
+
+
+def get_predictions(args, model, vocab_tokens, test_loader, device, start, multiplier=1):
+    all_predictions = []
+
+    log_rank_0(f"nbest = {(args.n_best * multiplier)}")
+    
+    with torch.no_grad():
+        for test_idx, test_batch in enumerate(test_loader):
+            if test_idx % args.log_iter == 0:
+                log_rank_0(f"Doing inference on test step {test_idx}, "
+                           f"time: {time.time() - start: .2f} s")
+
+            test_batch.to(device)
+            results = model.predict_step(
+                reaction_batch=test_batch,
+                batch_size=test_batch.size,
+                beam_size=args.beam_size,
+                n_best=args.n_best * multiplier,
+                temperature=args.temperature,
+                min_length=args.predict_min_len,
+                max_length=args.predict_max_len
+            )
+
+            for predictions, scores in zip(results["predictions"], results["scores"]):
+                smis_with_scores = []
+                for prediction, score in zip(predictions, scores):
+                    predicted_idx = prediction.detach().cpu().numpy()
+                    score = score.detach().cpu().numpy()
+                    predicted_tokens = [vocab_tokens[idx] for idx in predicted_idx[:-1]]
+                    smi = "".join(predicted_tokens)
+                    smis_with_scores.append(f"{smi}_{score}")
+                smis_with_scores = ",".join(smis_with_scores)
+                all_predictions.append(f"{smis_with_scores}\n")
+
+    return all_predictions
+
+
+def main(args):
+    args.device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+    device = args.device
+    if args.local_rank != -1:
+        dist.init_process_group(backend=args.backend, init_method='env://', timeout=datetime.timedelta(0, 7200))
+        torch.cuda.set_device(args.local_rank)
+        torch.backends.cudnn.benchmark = True
+
+    if torch.distributed.is_initialized():
+        log_rank_0(f"Device rank: {torch.distributed.get_rank()}")
+    os.makedirs(os.path.join("./results", args.data_name), exist_ok=True)
+    # os.makedirs(os.path.join("./results", args.test_output_path), exist_ok=True)
+
+    parsing.log_args(args, phase="prediction")
+
+    # initialization ---------------------------------- ckpt parsing
+    if args.do_validate:
+        checkpoints = glob.glob(os.path.join(args.load_from, "*.pt"))
+        checkpoints = sorted(
+            checkpoints,
+            key=lambda ckpt: int(ckpt.split(".")[-2].split("_")[-1]),
+            reverse=True
+        )
+        multipliers = [3] * len(checkpoints)
+        checkpoints = [ckpt for ckpt in checkpoints
+                       if (args.checkpoint_step_start <= int(ckpt.split(".")[-2].split("_")[1]))
+                       and (args.checkpoint_step_end >= int(ckpt.split(".")[-2].split("_")[1]))]
+        file_bin = os.path.join(args.processed_data_path, "val.npz")
+        file_tgt = os.path.join(args.processed_data_path, "tgt-val.txt")
+    elif args.do_predict:
+        # multipliers = [1, 3, 5, 10, 20]
+        multipliers = [3]
+        checkpoints = [os.path.join(args.model_path, args.load_from)]
+        file_bin = os.path.join(args.processed_data_path, "test.npz")
+        file_tgt = os.path.join(args.processed_data_path, "tgt-test.txt")
+    else:
+        raise ValueError("Either --do_validate or --do_predict need to be specified!")
+
+    model = None
+    test_dataset = None
+    vocab_tokens = None
+    smis_tgt = []
+    start = time.time()
+    for ckpt_i, checkpoint in enumerate(checkpoints):
+        result_file = os.path.join(args.test_output_path, f"result.{ckpt_i}")
+        result_stat_file = os.path.join(args.test_output_path, f"result.stat.{ckpt_i}")
+
+        if os.path.exists(result_file) and False:
+            log_rank_0(f"Result file found at {result_file}, skipping prediction.")
+        else:
+            log_rank_0(f"Loading from {checkpoint}")
+            try:
+                state = torch.load(checkpoint)
+            except RuntimeError:
+                log_rank_0(f"Error loading {checkpoint}, skipping")
+                continue            # some weird corrupted files
+
+            pretrain_args = state["args"]
+            pretrain_args.load_from = None     
+            pretrain_state_dict = state["state_dict"]
+            pretrain_args.local_rank = args.local_rank
+            if not hasattr(pretrain_args, "n_latent"):
+                pretrain_args.n_latent = 1
+            args.n_latent = pretrain_args.n_latent
+            if not hasattr(pretrain_args, "shared_attention_layer"):
+                pretrain_args.shared_attention_layer = 0
+
+            if model is None:
+                # initialization ---------------------------------- model
+                log_rank_0("Model is None, building model")
+                log_rank_0("First logging args for training")
+                parsing.log_args(pretrain_args, phase="training")
+
+                # backward
+                assert args.model == pretrain_args.model or \
+                    pretrain_args.model == "g2s_series_rel", \
+                    f"Pretrained model is {pretrain_args.model}!"
+                model_class = Graph2SMILES
+                dataset_class = G2SDataset
+                args.compute_graph_distance = True
+
+                # initialization ---------------------------------- vocab
+                vocab = load_vocab(args)
+                vocab_tokens = [k for k, v in sorted(vocab.items(), key=lambda tup: tup[1])]
+
+                model, state = get_model(pretrain_args, model_class, vocab, device)
+                if hasattr(model, "module"):
+                    model = model.module        # unwrap DDP model to enable accessing model func directly
+
+                log_rank_0(model)
+                log_rank_0(f"Number of parameters = {param_count(model)}")
+
+                # initialization ---------------------------------- data
+                test_dataset = dataset_class(args, file=file_bin)
+                test_dataset.batch(
+                    batch_type=args.batch_type,
+                    batch_size=args.predict_batch_size
+                )
+                with open(file_tgt, "r") as f:
+                    total = sum(1 for _ in f)
+
+                with open(file_tgt, "r") as f:
+                    for line_tgt in f:
+                        smi_tgt = "".join(line_tgt.split())
+                        smi_tgt = canonicalize_smiles(smi_tgt)
+                        smis_tgt.append(smi_tgt)
+
+            pretrain_state_dict = {k.replace("module.", ""): v for k, v in pretrain_state_dict.items()}
+            model.load_state_dict(pretrain_state_dict)
+            log_rank_0(f"Loaded pretrained state_dict from {checkpoint}")
+            model.eval()
+
+            if args.local_rank != -1:
+                test_sampler = DistributedSampler(test_dataset, shuffle=False)
+            else:
+                test_sampler = SequentialSampler(test_dataset)
+
+            test_loader = DataLoader(
+                dataset=test_dataset,
+                batch_size=1,
+                sampler=test_sampler,
+                num_workers=args.num_cores,
+                collate_fn=lambda _batch: _batch[0],
+                pin_memory=True
+            )
+
+            multiplier = multipliers[ckpt_i]
+            all_predictions = get_predictions(
+                args, model, vocab_tokens, test_loader, device, start, multiplier)
+
+            if args.local_rank > 0:
+                continue
+
+            # saving prediction results
+            with open(result_file, "w") as of:
+                of.writelines(all_predictions)
+
+        if args.do_score:
+            if os.path.exists(result_stat_file) and False:
+                log_rank_0(f"Result stat file found at {result_stat_file}, skipping scoring.")
+                continue
+
+            invalid = 0
+            accuracies = np.zeros([total, args.n_best], dtype=np.float32)
+
+            with open(result_file, "r") as f_predict:
+                for i, (smi_tgt, line_predict) in enumerate(zip(smis_tgt, f_predict)):
+                    if smi_tgt == "CC":         # problematic SMILES
+                        continue
+
+                    line_predict = "".join(line_predict.split())
+                    smis_predict = line_predict.split(",")
+                    smis_predict = [smi.split("_")[0] for smi in smis_predict]
+                    smis_predict = [canonicalize_smiles(smi, trim=False, suppress_warning=True) for smi in smis_predict]
+                    if not smis_predict[0]:
+                        invalid += 1
+                    smis_predict = [smi for smi in smis_predict if smi and not smi == "CC"]
+                    smis_predict = list(dict.fromkeys(smis_predict))
+
+                    for j, smi in enumerate(smis_predict[:args.n_best]):
+                        if smi == smi_tgt:
+                            accuracies[i, j:] = 1.0
+                            break
+
+            with open(result_stat_file, "w") as of:
+                line = f"Total: {total}, top 1 invalid: {invalid / total * 100: .2f} %"
+                log_rank_0(line)
+                of.write(f"{line}\n")
+
+                mean_accuracies = np.mean(accuracies, axis=0)
+                for n in range(args.n_best):
+                    line = f"Top {n+1} accuracy: {mean_accuracies[n] * 100: .2f} %"
+                    log_rank_0(line)
+                    of.write(f"{line}\n")
+
+            log_rank_0(f"Elapsed time: {time.time() - start: .2f} s")
+
+
+if __name__ == "__main__":
+    # initialization ---------------------------------- args, logs and devices
+    predict_parser = get_predict_parser()
+    args = predict_parser.parse_args()
+
+    setup_logger(args, warning_off=True)
+    np.set_printoptions(threshold=sys.maxsize)
+    torch.set_printoptions(profile="full")
+
+    set_seed(args.seed)
+
+    main(args)

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/mar_files/train.py

@@ -0,0 +1,287 @@
+import argparse
+import datetime
+import logging
+import numpy as np
+import os
+import sys
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+import torch.optim as optim
+from models.graph2smiles import Graph2SMILES
+import time
+from torch.nn.init import xavier_uniform_
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
+from torch.utils.data.distributed import DistributedSampler
+from typing import Dict
+from utils import parsing
+from utils.data_utils import G2SDataset
+from utils.preprocess_utils import load_vocab
+from utils.train_utils import get_lr, grad_norm, log_rank_0, NoamLR, \
+    param_count, param_norm, set_seed, setup_logger
+
+
+def get_train_parser():
+    parser = argparse.ArgumentParser("train")
+    parsing.add_common_args(parser)
+    parsing.add_train_args(parser)
+    parsing.add_predict_args(parser)
+
+    return parser
+
+
+def init_dist(args):
+    if args.local_rank != -1:
+        dist.init_process_group(backend=args.backend,
+                                init_method='env://',
+                                timeout=datetime.timedelta(0, 7200))
+        torch.cuda.set_device(args.local_rank)
+        torch.backends.cudnn.benchmark = False
+
+    if dist.is_initialized():
+        logging.info(f"Device rank: {dist.get_rank()}")
+        sys.stdout.flush()
+
+
+def get_model(args, model_class, vocab: Dict[str, int], device):
+    state = {}
+    if args.load_from:
+        log_rank_0(f"Loading pretrained state from {args.load_from}")
+        state = torch.load(args.load_from, map_location=torch.device("cpu"))
+        pretrain_args = state["args"]
+        pretrain_args.local_rank = args.local_rank
+        parsing.log_args(pretrain_args, phase="pretraining")
+
+        model = model_class(pretrain_args, vocab)
+        pretrain_state_dict = state["state_dict"]
+        pretrain_state_dict = {k.replace("module.", ""): v for k, v in pretrain_state_dict.items()}
+        model.load_state_dict(pretrain_state_dict)
+        log_rank_0("Loaded pretrained model state_dict.")
+    else:
+        model = model_class(args, vocab)
+        for p in model.parameters():
+            if p.dim() > 1 and p.requires_grad:
+                xavier_uniform_(p)
+
+    model.to(device)
+    if args.local_rank != -1:
+        model = DDP(
+            model,
+            device_ids=[args.local_rank],
+            output_device=args.local_rank
+        )
+        log_rank_0("DDP setup finished")
+
+    return model, state
+
+
+def get_optimizer_and_scheduler(args, model, state):
+    optimizer = optim.AdamW(
+        model.parameters(),
+        lr=args.lr,
+        betas=(args.beta1, args.beta2),
+        eps=args.eps,
+        weight_decay=args.weight_decay
+    )
+    scheduler = NoamLR(
+        optimizer,
+        model_size=args.decoder_hidden_size,
+        warmup_steps=args.warmup_steps
+    )
+
+    if state and args.resume:
+        optimizer.load_state_dict(state["optimizer"])
+        scheduler.load_state_dict(state["scheduler"])
+        log_rank_0("Loaded pretrained optimizer and scheduler state_dicts.")
+
+    return optimizer, scheduler
+
+
+def init_loader(args, dataset, batch_size: int, bucket_size: int = 1000,
+                shuffle: bool = False, epoch: int = None):
+    dataset.sort()
+    dataset.shuffle_in_bucket(bucket_size=bucket_size)
+    dataset.batch(
+        batch_type=args.batch_type,
+        batch_size=batch_size
+    )
+
+    if args.local_rank != -1:
+        sampler = DistributedSampler(dataset, shuffle=shuffle)
+        if epoch is not None:
+            sampler.set_epoch(epoch)
+    else:
+        sampler = RandomSampler(dataset) if shuffle else SequentialSampler(dataset)
+
+    loader = DataLoader(
+        dataset=dataset,
+        batch_size=1,
+        sampler=sampler,
+        num_workers=args.num_cores,
+        collate_fn=lambda _batch: _batch[0],
+        pin_memory=True
+    )
+
+    return loader
+
+
+def _optimize(args, model, optimizer, scheduler, accum_count):
+    # for param in model.parameters():
+    #     param.grad /= accum_count
+
+    nn.utils.clip_grad_norm_(model.parameters(), args.clip_norm)
+    optimizer.step()
+    scheduler.step()
+    g_norm = grad_norm(model)
+    model.zero_grad(set_to_none=True)
+
+    return g_norm
+
+
+def train_main(args):
+    args.device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
+    device = args.device
+
+    init_dist(args)
+    parsing.log_args(args, phase="training")
+
+    vocab_file = os.path.join(args.processed_data_path, "vocab.txt")
+    if not os.path.exists(vocab_file):
+        raise ValueError(f"Vocab file {vocab_file} not found!")
+    vocab = load_vocab(args)
+
+    os.makedirs(args.model_path, exist_ok=True)
+    model_class = Graph2SMILES
+    dataset_class = G2SDataset
+    assert args.compute_graph_distance
+
+    model, state = get_model(args, model_class, vocab, device)
+    log_rank_0(model)
+    log_rank_0(f"Number of parameters = {param_count(model)}")
+
+    optimizer, scheduler = get_optimizer_and_scheduler(args, model, state)
+
+    train_bin = os.path.join(args.processed_data_path, "train.npz")
+    val_bin = os.path.join(args.processed_data_path, "val.npz")
+
+    train_dataset = dataset_class(args, file=train_bin)
+    val_dataset = dataset_class(args, file=val_bin)
+
+    total_step = state["total_step"] if state else 0
+    accum = 0
+    g_norm = 0
+    losses, accs, ems = [], [], []
+    o_start = time.time()
+    log_rank_0("Start training")
+
+    for epoch in range(args.epoch):
+        model.train()
+        model.zero_grad(set_to_none=True)
+        train_loader = init_loader(args, train_dataset,
+                                   batch_size=args.train_batch_size,
+                                   shuffle=True,
+                                   epoch=epoch)
+        for batch_idx, train_batch in enumerate(train_loader):
+            
+            if train_batch is None:
+                log_rank_0("Fail distance compute, too large due to node size")
+                continue
+
+            if total_step > args.max_steps:
+                log_rank_0("Max steps reached, finish training")
+                exit(0)
+            train_batch.to(device)
+            batch_losses, acc, em = model(train_batch)
+            loss = batch_losses.mean()
+            (loss / args.accumulation_count).backward() # average out the loss over multiple batches during accumulation
+            losses.append(loss.item())
+            accs.append(acc.item() * 100)
+            ems.append(em.item() * 100)
+
+            accum += 1
+            if accum == args.accumulation_count:
+                g_norm = _optimize(args, model, optimizer, scheduler, args.accumulation_count)
+                accum = 0
+                total_step += 1
+
+            if (accum == 0) and (total_step > 0) and (total_step % args.log_iter == 0):
+                log_rank_0(f"Step {total_step}, loss: {np.mean(losses)}, "
+                           f"acc: {np.mean(accs): .4f}, em: {np.mean(ems): .4f}, "
+                           f"p_norm: {param_norm(model): .4f}, g_norm: {g_norm: .4f}, "
+                           f"lr: {get_lr(optimizer): .6f}, "
+                           f"elapsed time: {time.time() - o_start: .0f}")
+                losses, accs, ems = [], [], []
+
+            if (accum == 0) and (total_step > 0) and (total_step % args.eval_iter == 0):
+                model.eval()
+                val_count = 100
+                val_losses, val_accs, val_ems = [], [], []
+
+                val_loader = init_loader(args, val_dataset,
+                                         batch_size=args.val_batch_size,
+                                         shuffle=True,
+                                         epoch=None)
+                with torch.no_grad():
+                    for val_idx, val_batch in enumerate(val_loader):
+                        if val_batch is None:
+                            log_rank_0("Fail distance compute, too large due to node size")
+                            continue
+
+                        if val_idx >= val_count:
+                            break
+                        val_batch.to(device)
+                        val_batch_losses, val_acc, val_em = model(val_batch)
+                        val_loss = val_batch_losses.mean()
+                        val_losses.append(val_loss.item())
+                        val_accs.append(val_acc.item() * 100)
+                        val_ems.append(val_em.item() * 100)
+
+                log_rank_0(f"Validation (with teacher) at step {total_step}, "
+                           f"val loss: {np.mean(val_losses)}, "
+                           f"val acc: {np.mean(val_accs): .4f}, "
+                           f"val em: {np.mean(val_ems): .4f}")
+                model.train()
+
+            # Important: saving only at one node or the ckpt would be corrupted!
+            if dist.is_initialized() and dist.get_rank() > 0:
+                continue
+
+            if (accum == 0) and (total_step > 0) and (total_step % args.save_iter == 0):
+                n_iter = total_step // args.save_iter - 1
+                log_rank_0(f"Saving at step {total_step}")
+                state = {
+                    "args": args,
+                    "total_step": total_step,
+                    "state_dict": model.state_dict(),
+                    "optimizer": optimizer.state_dict(),
+                    "scheduler": scheduler.state_dict()
+                }
+                torch.save(state, os.path.join(args.model_path, f"model.{total_step}_{n_iter}.pt"))
+
+        # lastly
+        if (args.accumulation_count > 1) and (accum > 0):
+            g_norm = _optimize(args, model, optimizer, scheduler, args.accumulation_count)
+            accum = 0
+            # total_step += 1           # for partial batch, do not increase total_step
+
+        if args.local_rank != -1:
+            dist.barrier()
+
+
+if __name__ == "__main__":
+    train_parser = get_train_parser()
+    args = train_parser.parse_args()
+
+    # set random seed
+    set_seed(args.seed)
+
+    # logger setup
+    logger = setup_logger(args)
+
+    # maximize display for debugging
+    np.set_printoptions(threshold=sys.maxsize)
+    torch.set_printoptions(profile="full")
+
+    args.local_rank = int(os.environ["LOCAL_RANK"]) if os.environ.get("LOCAL_RANK") else -1
+    train_main(args)

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/mar_files/vocab.txt

@@ -0,0 +1,518 @@
+_PAD
+_UNK
+_SOS
+_EOS
+C	71366957
+O	26043977
+(	42614880
+=	14509133
+)	42614880
+c	88555236
+1	23870848
+N	11386141
+2	15944130
+3	7286876
+4	2643446
+n	9640471
+5	812956
+6	234756
+[nH]	841266
+7	74414
+-	2618845
+8	26942
+[C@H]	2113649
+o	525176
+[C@@H]	2151298
+S	1586078
+[N+]	539390
+[O-]	502732
+s	718167
+[C@@]	226220
+F	5392896
+Cl	2694145
+#	870630
+[Si]	364752
+I	249124
+P	154421
+/	583748
+Br	1230889
+B	290641
+[C@]	256261
+\	138044
+[2H]	140180
+[N-]	81532
+[Li]	26276
+[Se]	3298
+[S]	2125
+[n+]	25340
+[Na]	91398
+[s+]	267
+[C]	1245
+[S@]	11769
+[S@@]	10494
+[P+]	8009
+[Te]	188
+[S+]	2647
+9	9238
+[CH2]	761
+[K]	59765
+[Zr-2]	22
+[C-]	8025
+[Hf]	106
+[19F]	28
+[18F]	1078
+[Zn]	10227
+[se]	2302
+[Al]	1828
+%10	3146
+[SiH2]	2831
+[Ca]	1528
+[131I]	14
+[PH]	4148
+[Ag]	545
+[Sn]	21897
+[NH]	1491
+[SH]	2131
+[15nH]	17
+[13c]	268
+[Ir]	199
+%11	1922
+%12	1192
+%13	802
+%14	576
+%15	458
+%16	398
+%17	272
+%18	212
+%19	184
+%20	194
+%21	132
+[SiH]	4689
+[Ge]	681
+[NH2+]	3122
+[Fe]	1209
+[K+]	12
+[Mg]	25244
+[Ti]	732
+[Cs]	10834
+[O]	1822
+[B-]	9477
+[c-]	448
+[S@@+]	291
+[P]	1351
+[Pd]	268
+[SiH3]	746
+[n-]	399
+[11CH3]	102
+[125I]	84
+[CH]	554
+[C+]	309
+[NH3+]	4724
+[P@]	1448
+[P-]	52
+[Zr]	210
+[N]	434
+[H]	1058
+[N@]	534
+[NH+]	1930
+%22	116
+%23	88
+%24	82
+[Ru]	356
+[nH+]	2000
+[PH2]	345
+[P@@]	1221
+[YH]	20
+[N@@]	517
+[c+]	45
+[Mn]	1047
+[o+]	238
+[cH-]	259
+[SeH]	168
+[Pt]	183
+[p+]	6
+[99Tc]	2
+[BH]	216
+[S@+]	272
+p	336
+[Cu]	3973
+[211At]	8
+[IrH2]	3
+[pH]	12
+[Pb]	371
+[Si@@H]	275
+[CH+]	63
+[te]	203
+[Tb]	4
+[Co]	173
+[Cl+]	1706
+[S-]	1123
+[In]	74
+[Nb]	40
+[Be]	24
+[B]	377
+[O+]	4734
+[OH2+]	18
+[13C]	303
+%25	64
+[123I]	51
+%26	46
+%27	50
+%28	60
+%29	44
+%30	40
+%31	42
+%32	50
+%33	34
+%34	34
+%35	24
+%36	36
+%37	26
+%38	24
+%39	24
+%40	32
+%41	24
+%42	24
+%43	20
+[W]	36
+[N@+]	44
+[13CH2]	127
+[Sc]	7
+[As]	203
+[SiH4]	40
+[14c]	17
+[AlH]	875
+[Na+]	97
+[CH-]	208
+[OH+]	108
+[SH2]	78
+[Zn+2]	36
+[68Ga]	2
+[Hg]	131
+[Cr]	1600
+[Ni]	173
+[Sb]	127
+[13cH]	109
+[CH2-]	295
+[Ta]	25
+[I+]	272
+[Lu]	23
+[Sr]	11
+[Si@]	154
+[Si@@]	151
+[Mo]	206
+[siH]	14
+[15NH2]	49
+[11c]	1
+[TeH]	40
+[I-]	15
+[Ga]	37
+[Gd]	8
+[Tc]	3
+[Pr]	2
+[GeH3]	7
+[124I]	15
+[13CH3]	151
+[15N]	18
+[NH-]	495
+[CH2+]	172
+[H+]	145
+[I+2]	20
+[P@@H]	2
+[64Cu]	1
+[14C]	59
+[Li+]	9
+[La]	108
+[TeH3]	4
+[SbH2]	4
+[Bi]	270
+[BH3-]	1781
+[13CH]	22
+[B@@-]	4
+[15N+]	7
+[15NH]	22
+[15OH]	1
+[Ne]	5
+[Ba]	21
+[Au]	121
+[Fm]	10
+[Eu]	17
+[Si@H]	67
+[14CH]	23
+[GeH2]	3
+[c]	15
+[N@@+]	25
+[S+2]	74
+[Th]	4
+[SnH2]	30
+[SnH]	333
+[11C]	9
+[InH2]	18
+[U]	2
+[As+]	5
+b	22
+[Ag+]	41
+[14cH]	4
+[SH+]	58
+[Rh]	31
+[IH]	38
+[Os]	12
+[Gd+3]	34
+[3H]	178
+[cH+]	61
+[Ce]	60
+[B@-]	8
+[SnH3]	80
+[Re]	12
+[PH+]	248
+[15NH2+]	2
+[AsH2]	4
+[18O]	23
+[Sn+2]	10
+[I+3]	867
+[13C-]	2
+[Mg+]	5
+[Cl+2]	20
+[10B]	7
+[TaH3]	3
+[NiH]	3
+[15n]	18
+[113C]	2
+[CH3+]	37
+[se+]	16
+[IrH]	9
+[Au-]	3
+[TiH]	5
+[14CH3]	24
+[V]	17
+[Fe+2]	116
+[Cl+3]	268
+[AsH]	10
+[32P]	8
+[SH4]	5
+[Mn+2]	2
+[F-]	2223
+[13C@@H]	3
+[GeH]	12
+[N@H+]	6
+[ZrH2]	1
+[Cu+]	8
+[F+]	7
+[14C@@H]	2
+[3Si]	2
+[Rh+]	1
+[P@@+]	1
+%44	8
+%45	8
+%46	8
+%47	8
+%48	4
+%49	4
+[Si-]	33
+[17O]	4
+[Y]	3
+[Po]	2
+[te+]	2
+[si]	5
+[16F]	3
+[79Br]	1
+[Se+]	2
+[CaH]	2
+[177Lu]	2
+[Cu-2]	4
+[13NH2]	1
+[Ho]	4
+[PH4]	8
+[Br+2]	34
+[Cu+2]	77
+[14CH2]	8
+[4He]	1
+[SbH]	2
+[NaH]	1
+[Ar]	19
+[N+2]	3
+[5O]	1
+[N@@H+]	6
+[ClH+]	4
+[Ti+]	1
+[AlH3]	3
+[BH-]	2762
+[Yb]	7
+[Ba+2]	64
+[Cr+]	1
+[He]	3
+[RuH]	8
+[Li-2]	2
+[Dy]	2
+[Si+]	8
+[YH3]	1
+[Co+2]	125
+[Ni+2]	7
+[Sb-]	8
+[Fe+3]	23
+[Zn+]	12
+.	2797764
+[Bi+2]	4
+[Ir+]	2
+[H-]	296
+[AlH2-]	59
+[S-2]	120
+[Eu+3]	2
+[Fe-4]	64
+[AlH-]	19
+[PH4+]	9
+[Fe-3]	30
+[In+3]	2
+*	166
+[Pt-2]	9
+[Al-]	30
+[Cs+]	16
+[Tl+3]	20
+[Sb+5]	7
+[Se-]	6
+[Pb+2]	9
+[Hf+2]	19
+[Yb+3]	37
+[Ce+4]	115
+[PH2+]	10
+[BH4-]	214
+[PH3]	26
+[PH3+]	103
+[AlH4-]	44
+[Al+3]	39
+[Al+]	77
+[CH3-]	98
+[Ti+3]	67
+[AlH4]	8
+[Ti+4]	4
+[Ce+3]	47
+[Tl]	24
+[P+3]	54
+[sH+]	12
+[Tl+]	22
+[SH3+]	2
+[SeH2]	15
+[Sr+2]	4
+[Ti+2]	10
+[SeH-]	8
+[Br+]	26
+[SH2+]	14
+[TeH2]	1
+[F]	2
+[Ga+]	5
+[Ge-]	4
+[Ac-]	2
+[B+]	20
+[Ce+2]	3
+[Bi+3]	16
+[SH-]	40
+[Er+3]	2
+[InH]	4
+[Pd+2]	21
+[Zr+4]	7
+[Zr+2]	8
+[B+3]	5
+[Cu-]	6
+[Cr+3]	9
+[La+3]	9
+[Mn+3]	3
+[IH+]	14
+[Pt-]	1
+[BH+]	2
+[Sb+3]	11
+[Cd]	4
+[AlH2]	6
+[Hg+]	11
+[Hg+2]	19
+[C+4]	33
+[18F-]	16
+[Si+4]	14
+[Bi+]	2
+[Cr-]	2
+[CH3]	18
+[U+2]	3
+[Xe]	16
+[Tl+2]	3
+[AlH2+]	1
+[35S]	2
+[Cu+3]	1
+[BH2-]	3
+[Zr+3]	3
+[AsH+]	1
+[225Ac]	2
+[SnH4]	4
+[Sn+4]	7
+[Mg+2]	2
+[Rb]	5
+[Mn+]	2
+[2NH2]	2
+[Rf]	1
+[113CH2]	1
+[Pt+2]	3
+[UH]	3
+[Ga+2]	2
+[V+2]	2
+[Hf+4]	2
+[WH]	1
+[Fr]	1
+[W+6]	1
+[Y+3]	2
+[No]	1
+[Sn-]	1
+[1H]	2
+[YH7]	1
+[IH2]	1
+[Se-2]	1
+[Ta+5]	1
+[Cd+2]	1
+[B+2]	7
+[Sb+2]	1
+[SiH4+]	1
+[C+2]	4
+[P@H]	1
+[NH+3]	1
+[Se+2]	1
+[oH+]	1
+[p-]	1
+[18OH]	1
+[Co+3]	1
+[Y-]	1
+[C-4]	1
+[2H+]	1
+[3H+]	1
+[BiH3]	1
+[FH+]	1
+[PH-]	4
+[Ge+4]	1
+[AsH3]	1
+[Sm+2]	1
+[As+3]	2
+[Br+3]	1
+[SH3]	1
+[BrH+]	2
+[113CH3]	1
+[Ta+2]	1
+[NH3+2]	2
+[Yb+2]	1
+[Cr+2]	2
+[I]	1
+[AlH3-]	1
+[2OH]	1
+[166Ho]	1
+[BaH2]	1
+[P-3]	1
+[35SH]	1
+[Cm]	1
+[11CH4]	1
+[YH2]	1
+[P+2]	1
+[3CH]	1
+[FH+2]	1
+[P+5]	4
+[Ga+3]	1
+[Bi+5]	1
+[Au+3]	1
+[14C@H]	1
+[Sm+3]	2
+[TiH2]	1
+[Hs]	1

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/mar_members.json

@@ -0,0 +1,52 @@
+{
+  "members": [
+    {
+      "compress_size": 14464,
+      "modified": "2024-10-19T01:31:36",
+      "path": "models.zip",
+      "size": 15292
+    },
+    {
+      "compress_size": 3031,
+      "modified": "2024-05-21T19:03:46",
+      "path": "predict.py",
+      "size": 10598
+    },
+    {
+      "compress_size": 2907,
+      "modified": "2024-10-19T01:31:36",
+      "path": "handler.py",
+      "size": 11445
+    },
+    {
+      "compress_size": 2239,
+      "modified": "2024-03-29T14:02:38",
+      "path": "vocab.txt",
+      "size": 4650
+    },
+    {
+      "compress_size": 2985,
+      "modified": "2024-04-11T15:23:02",
+      "path": "train.py",
+      "size": 10272
+    },
+    {
+      "compress_size": 200853489,
+      "modified": "2024-10-19T01:31:36",
+      "path": "model.pt",
+      "size": 221922825
+    },
+    {
+      "compress_size": 16788,
+      "modified": "2024-10-19T01:31:36",
+      "path": "utils.zip",
+      "size": 17742
+    },
+    {
+      "compress_size": 143,
+      "modified": "2024-10-19T01:31:48",
+      "path": "MAR-INF/MANIFEST.json",
+      "size": 205
+    }
+  ]
+}

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/model_args.json

@@ -0,0 +1,79 @@
+{
+  "accumulation_count": 16,
+  "attn_dropout": 0.1,
+  "attn_enc_filter_size": 2048,
+  "attn_enc_heads": 8,
+  "attn_enc_hidden_size": 256,
+  "attn_enc_num_layers": 6,
+  "backend": "nccl",
+  "batch_type": "tokens_sum",
+  "beam_size": 5,
+  "beta1": 0.9,
+  "beta2": 0.998,
+  "checkpoint_step_end": null,
+  "checkpoint_step_start": null,
+  "clip_norm": 20.0,
+  "compute_graph_distance": true,
+  "data_name": "pistachio_clean_Q3",
+  "decoder_attn_heads": 8,
+  "decoder_filter_size": 2048,
+  "decoder_hidden_size": 256,
+  "decoder_num_layers": 6,
+  "device": "cuda",
+  "dgat_attn_heads": 8,
+  "do_predict": false,
+  "do_profile": false,
+  "do_score": false,
+  "do_validate": false,
+  "dropout": 0.1,
+  "embed_size": 256,
+  "enable_amp": false,
+  "encoder_attn_heads": 8,
+  "encoder_emb_scale": "sqrt",
+  "encoder_filter_size": 2048,
+  "encoder_hidden_size": 256,
+  "encoder_norm": "none",
+  "encoder_num_layers": 4,
+  "encoder_positional_encoding": "none",
+  "encoder_skip_connection": "none",
+  "epoch": 2000,
+  "eps": 1e-09,
+  "eval_iter": 5000,
+  "load_from": "/home/gridsan/ztu/retrain/retro/graph2smiles/checkpoints/pistachio_clean_Q3_single_gpu_large_batch2/model.250000_24.pt",
+  "local_rank": 0,
+  "log_file": "graph2smiles_train_pistachio_clean_Q3",
+  "log_iter": 100,
+  "lr": 4.0,
+  "mask_rel_chirality": 0,
+  "max_relative_positions": 4,
+  "max_src_len": 512,
+  "max_steps": 4000000,
+  "max_tgt_len": 512,
+  "model": "graph2smiles",
+  "model_path": "/home/gridsan/ztu/retrain/retro/graph2smiles/checkpoints/pistachio_clean_Q3_single_gpu_large_batch2",
+  "mpn_type": "dgcn",
+  "n_best": 10,
+  "n_latent": "1",
+  "num_cores": 32,
+  "predict_batch_size": 4096,
+  "predict_max_len": 512,
+  "predict_min_len": 1,
+  "processed_data_path": "/home/gridsan/ztu/retrain/retro/graph2smiles/data/pistachio_clean_Q3/processed",
+  "record_shapes": false,
+  "rel_pos": "emb_only",
+  "rel_pos_buckets": 15,
+  "result_file": "",
+  "resume": true,
+  "save_iter": 10000,
+  "seed": 42,
+  "share_embeddings": false,
+  "shared_attention_layer": 0,
+  "task": "reaction_prediction",
+  "temperature": 1.0,
+  "test_output_path": "",
+  "train_batch_size": 4096,
+  "val_batch_size": 4096,
+  "verbose": false,
+  "warmup_steps": 8000,
+  "weight_decay": 0.0
+}

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/safetensors_conversion.json

@@ -0,0 +1,14 @@
+{
+  "format": "safetensors",
+  "num_tensors": 297,
+  "path": "model.safetensors",
+  "roundtrip_tensor_equal": true,
+  "runtime_assets": {
+    "checkpoint_metadata": "aux/checkpoint_metadata.json",
+    "model_args": "aux/model_args.json",
+    "runtime_source_dir": "aux/graph2smiles_runtime",
+    "vocab": "aux/vocab.txt"
+  },
+  "source_member": "model.pt",
+  "status": "converted"
+}

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/aux/vocab.txt

@@ -0,0 +1,518 @@
+_PAD
+_UNK
+_SOS
+_EOS
+C	71366957
+O	26043977
+(	42614880
+=	14509133
+)	42614880
+c	88555236
+1	23870848
+N	11386141
+2	15944130
+3	7286876
+4	2643446
+n	9640471
+5	812956
+6	234756
+[nH]	841266
+7	74414
+-	2618845
+8	26942
+[C@H]	2113649
+o	525176
+[C@@H]	2151298
+S	1586078
+[N+]	539390
+[O-]	502732
+s	718167
+[C@@]	226220
+F	5392896
+Cl	2694145
+#	870630
+[Si]	364752
+I	249124
+P	154421
+/	583748
+Br	1230889
+B	290641
+[C@]	256261
+\	138044
+[2H]	140180
+[N-]	81532
+[Li]	26276
+[Se]	3298
+[S]	2125
+[n+]	25340
+[Na]	91398
+[s+]	267
+[C]	1245
+[S@]	11769
+[S@@]	10494
+[P+]	8009
+[Te]	188
+[S+]	2647
+9	9238
+[CH2]	761
+[K]	59765
+[Zr-2]	22
+[C-]	8025
+[Hf]	106
+[19F]	28
+[18F]	1078
+[Zn]	10227
+[se]	2302
+[Al]	1828
+%10	3146
+[SiH2]	2831
+[Ca]	1528
+[131I]	14
+[PH]	4148
+[Ag]	545
+[Sn]	21897
+[NH]	1491
+[SH]	2131
+[15nH]	17
+[13c]	268
+[Ir]	199
+%11	1922
+%12	1192
+%13	802
+%14	576
+%15	458
+%16	398
+%17	272
+%18	212
+%19	184
+%20	194
+%21	132
+[SiH]	4689
+[Ge]	681
+[NH2+]	3122
+[Fe]	1209
+[K+]	12
+[Mg]	25244
+[Ti]	732
+[Cs]	10834
+[O]	1822
+[B-]	9477
+[c-]	448
+[S@@+]	291
+[P]	1351
+[Pd]	268
+[SiH3]	746
+[n-]	399
+[11CH3]	102
+[125I]	84
+[CH]	554
+[C+]	309
+[NH3+]	4724
+[P@]	1448
+[P-]	52
+[Zr]	210
+[N]	434
+[H]	1058
+[N@]	534
+[NH+]	1930
+%22	116
+%23	88
+%24	82
+[Ru]	356
+[nH+]	2000
+[PH2]	345
+[P@@]	1221
+[YH]	20
+[N@@]	517
+[c+]	45
+[Mn]	1047
+[o+]	238
+[cH-]	259
+[SeH]	168
+[Pt]	183
+[p+]	6
+[99Tc]	2
+[BH]	216
+[S@+]	272
+p	336
+[Cu]	3973
+[211At]	8
+[IrH2]	3
+[pH]	12
+[Pb]	371
+[Si@@H]	275
+[CH+]	63
+[te]	203
+[Tb]	4
+[Co]	173
+[Cl+]	1706
+[S-]	1123
+[In]	74
+[Nb]	40
+[Be]	24
+[B]	377
+[O+]	4734
+[OH2+]	18
+[13C]	303
+%25	64
+[123I]	51
+%26	46
+%27	50
+%28	60
+%29	44
+%30	40
+%31	42
+%32	50
+%33	34
+%34	34
+%35	24
+%36	36
+%37	26
+%38	24
+%39	24
+%40	32
+%41	24
+%42	24
+%43	20
+[W]	36
+[N@+]	44
+[13CH2]	127
+[Sc]	7
+[As]	203
+[SiH4]	40
+[14c]	17
+[AlH]	875
+[Na+]	97
+[CH-]	208
+[OH+]	108
+[SH2]	78
+[Zn+2]	36
+[68Ga]	2
+[Hg]	131
+[Cr]	1600
+[Ni]	173
+[Sb]	127
+[13cH]	109
+[CH2-]	295
+[Ta]	25
+[I+]	272
+[Lu]	23
+[Sr]	11
+[Si@]	154
+[Si@@]	151
+[Mo]	206
+[siH]	14
+[15NH2]	49
+[11c]	1
+[TeH]	40
+[I-]	15
+[Ga]	37
+[Gd]	8
+[Tc]	3
+[Pr]	2
+[GeH3]	7
+[124I]	15
+[13CH3]	151
+[15N]	18
+[NH-]	495
+[CH2+]	172
+[H+]	145
+[I+2]	20
+[P@@H]	2
+[64Cu]	1
+[14C]	59
+[Li+]	9
+[La]	108
+[TeH3]	4
+[SbH2]	4
+[Bi]	270
+[BH3-]	1781
+[13CH]	22
+[B@@-]	4
+[15N+]	7
+[15NH]	22
+[15OH]	1
+[Ne]	5
+[Ba]	21
+[Au]	121
+[Fm]	10
+[Eu]	17
+[Si@H]	67
+[14CH]	23
+[GeH2]	3
+[c]	15
+[N@@+]	25
+[S+2]	74
+[Th]	4
+[SnH2]	30
+[SnH]	333
+[11C]	9
+[InH2]	18
+[U]	2
+[As+]	5
+b	22
+[Ag+]	41
+[14cH]	4
+[SH+]	58
+[Rh]	31
+[IH]	38
+[Os]	12
+[Gd+3]	34
+[3H]	178
+[cH+]	61
+[Ce]	60
+[B@-]	8
+[SnH3]	80
+[Re]	12
+[PH+]	248
+[15NH2+]	2
+[AsH2]	4
+[18O]	23
+[Sn+2]	10
+[I+3]	867
+[13C-]	2
+[Mg+]	5
+[Cl+2]	20
+[10B]	7
+[TaH3]	3
+[NiH]	3
+[15n]	18
+[113C]	2
+[CH3+]	37
+[se+]	16
+[IrH]	9
+[Au-]	3
+[TiH]	5
+[14CH3]	24
+[V]	17
+[Fe+2]	116
+[Cl+3]	268
+[AsH]	10
+[32P]	8
+[SH4]	5
+[Mn+2]	2
+[F-]	2223
+[13C@@H]	3
+[GeH]	12
+[N@H+]	6
+[ZrH2]	1
+[Cu+]	8
+[F+]	7
+[14C@@H]	2
+[3Si]	2
+[Rh+]	1
+[P@@+]	1
+%44	8
+%45	8
+%46	8
+%47	8
+%48	4
+%49	4
+[Si-]	33
+[17O]	4
+[Y]	3
+[Po]	2
+[te+]	2
+[si]	5
+[16F]	3
+[79Br]	1
+[Se+]	2
+[CaH]	2
+[177Lu]	2
+[Cu-2]	4
+[13NH2]	1
+[Ho]	4
+[PH4]	8
+[Br+2]	34
+[Cu+2]	77
+[14CH2]	8
+[4He]	1
+[SbH]	2
+[NaH]	1
+[Ar]	19
+[N+2]	3
+[5O]	1
+[N@@H+]	6
+[ClH+]	4
+[Ti+]	1
+[AlH3]	3
+[BH-]	2762
+[Yb]	7
+[Ba+2]	64
+[Cr+]	1
+[He]	3
+[RuH]	8
+[Li-2]	2
+[Dy]	2
+[Si+]	8
+[YH3]	1
+[Co+2]	125
+[Ni+2]	7
+[Sb-]	8
+[Fe+3]	23
+[Zn+]	12
+.	2797764
+[Bi+2]	4
+[Ir+]	2
+[H-]	296
+[AlH2-]	59
+[S-2]	120
+[Eu+3]	2
+[Fe-4]	64
+[AlH-]	19
+[PH4+]	9
+[Fe-3]	30
+[In+3]	2
+*	166
+[Pt-2]	9
+[Al-]	30
+[Cs+]	16
+[Tl+3]	20
+[Sb+5]	7
+[Se-]	6
+[Pb+2]	9
+[Hf+2]	19
+[Yb+3]	37
+[Ce+4]	115
+[PH2+]	10
+[BH4-]	214
+[PH3]	26
+[PH3+]	103
+[AlH4-]	44
+[Al+3]	39
+[Al+]	77
+[CH3-]	98
+[Ti+3]	67
+[AlH4]	8
+[Ti+4]	4
+[Ce+3]	47
+[Tl]	24
+[P+3]	54
+[sH+]	12
+[Tl+]	22
+[SH3+]	2
+[SeH2]	15
+[Sr+2]	4
+[Ti+2]	10
+[SeH-]	8
+[Br+]	26
+[SH2+]	14
+[TeH2]	1
+[F]	2
+[Ga+]	5
+[Ge-]	4
+[Ac-]	2
+[B+]	20
+[Ce+2]	3
+[Bi+3]	16
+[SH-]	40
+[Er+3]	2
+[InH]	4
+[Pd+2]	21
+[Zr+4]	7
+[Zr+2]	8
+[B+3]	5
+[Cu-]	6
+[Cr+3]	9
+[La+3]	9
+[Mn+3]	3
+[IH+]	14
+[Pt-]	1
+[BH+]	2
+[Sb+3]	11
+[Cd]	4
+[AlH2]	6
+[Hg+]	11
+[Hg+2]	19
+[C+4]	33
+[18F-]	16
+[Si+4]	14
+[Bi+]	2
+[Cr-]	2
+[CH3]	18
+[U+2]	3
+[Xe]	16
+[Tl+2]	3
+[AlH2+]	1
+[35S]	2
+[Cu+3]	1
+[BH2-]	3
+[Zr+3]	3
+[AsH+]	1
+[225Ac]	2
+[SnH4]	4
+[Sn+4]	7
+[Mg+2]	2
+[Rb]	5
+[Mn+]	2
+[2NH2]	2
+[Rf]	1
+[113CH2]	1
+[Pt+2]	3
+[UH]	3
+[Ga+2]	2
+[V+2]	2
+[Hf+4]	2
+[WH]	1
+[Fr]	1
+[W+6]	1
+[Y+3]	2
+[No]	1
+[Sn-]	1
+[1H]	2
+[YH7]	1
+[IH2]	1
+[Se-2]	1
+[Ta+5]	1
+[Cd+2]	1
+[B+2]	7
+[Sb+2]	1
+[SiH4+]	1
+[C+2]	4
+[P@H]	1
+[NH+3]	1
+[Se+2]	1
+[oH+]	1
+[p-]	1
+[18OH]	1
+[Co+3]	1
+[Y-]	1
+[C-4]	1
+[2H+]	1
+[3H+]	1
+[BiH3]	1
+[FH+]	1
+[PH-]	4
+[Ge+4]	1
+[AsH3]	1
+[Sm+2]	1
+[As+3]	2
+[Br+3]	1
+[SH3]	1
+[BrH+]	2
+[113CH3]	1
+[Ta+2]	1
+[NH3+2]	2
+[Yb+2]	1
+[Cr+2]	2
+[I]	1
+[AlH3-]	1
+[2OH]	1
+[166Ho]	1
+[BaH2]	1
+[P-3]	1
+[35SH]	1
+[Cm]	1
+[11CH4]	1
+[YH2]	1
+[P+2]	1
+[3CH]	1
+[FH+2]	1
+[P+5]	4
+[Ga+3]	1
+[Bi+5]	1
+[Au+3]	1
+[14C@H]	1
+[Sm+3]	2
+[TiH2]	1
+[Hs]	1

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/benchmarks/metadata.json

@@ -0,0 +1,15 @@
+{
+  "benchmark_variant": "benchmark_pending",
+  "built_at": "1970-01-01T00:00:00+00:00",
+  "checkpoint_id": "pistachio_23q3",
+  "dataset_id": "askcos_retro_graph2smiles_pistachio_23q3_benchmark_pending",
+  "dataset_ref": "askcos_pistachio_23q3_release",
+  "native_input_format": "benchmark_not_available",
+  "native_sources": [],
+  "notes": [
+    "No redistribution-safe native benchmark split for this ASKCOS model archive is staged in this repository.",
+    "The bundle keeps benchmark metadata so downstream tooling can distinguish unavailable benchmarks from accidental omissions."
+  ],
+  "num_examples": 0,
+  "split": "test"
+}

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/manifest.json

@@ -0,0 +1,162 @@
+{
+  "auxiliary_files": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/checkpoint_metadata.json",
+    "aux/graph2smiles_runtime/models/attention_xl.py",
+    "aux/graph2smiles_runtime/models/dgat.py",
+    "aux/graph2smiles_runtime/models/dgcn.py",
+    "aux/graph2smiles_runtime/models/graph2smiles.py",
+    "aux/graph2smiles_runtime/models/graphfeat.py",
+    "aux/graph2smiles_runtime/models/model_utils.py",
+    "aux/graph2smiles_runtime/models/transformer_decoder.py",
+    "aux/graph2smiles_runtime/predict.py",
+    "aux/graph2smiles_runtime/train.py",
+    "aux/graph2smiles_runtime/utils/c_calculate.so",
+    "aux/graph2smiles_runtime/utils/chem_utils.py",
+    "aux/graph2smiles_runtime/utils/ctypes_calculator.py",
+    "aux/graph2smiles_runtime/utils/data_utils.py",
+    "aux/graph2smiles_runtime/utils/parsing.py",
+    "aux/graph2smiles_runtime/utils/preprocess_utils.py",
+    "aux/graph2smiles_runtime/utils/rxn_graphs.py",
+    "aux/graph2smiles_runtime/utils/train_utils.py",
+    "aux/mar_files/handler.py",
+    "aux/mar_files/models.zip",
+    "aux/mar_files/predict.py",
+    "aux/mar_files/train.py",
+    "aux/mar_files/utils.zip",
+    "aux/mar_files/vocab.txt",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/vocab.txt",
+    "benchmarks/default_test.jsonl",
+    "benchmarks/metadata.json"
+  ],
+  "benchmark_datasets": [
+    {
+      "benchmark_variant": "benchmark_pending",
+      "dataset_id": "askcos_retro_graph2smiles_pistachio_23q3_benchmark_pending",
+      "dataset_ref": "askcos_pistachio_23q3_release",
+      "default": true,
+      "format": "jsonl",
+      "metadata_path": "benchmarks/metadata.json",
+      "native_input_format": "benchmark_not_available",
+      "native_source_paths": [],
+      "notes": [
+        "No redistribution-safe native benchmark split for this ASKCOS model archive is staged in this repository.",
+        "The bundle keeps benchmark metadata so downstream tooling can distinguish unavailable benchmarks from accidental omissions."
+      ],
+      "num_examples": 0,
+      "path": "benchmarks/default_test.jsonl",
+      "split": "test"
+    }
+  ],
+  "checkpoint_id": "pistachio_23q3",
+  "contained_artifact_bindings": [
+    {
+      "canonical_split_family": "askcos_pistachio_23q3_split_unspecified",
+      "dataset_ref": "askcos_pistachio_23q3_release",
+      "path": "modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "conversion": {
+    "converted_at": "1970-01-01T00:00:00+00:00",
+    "notes": [
+      "The upstream ASKCOS TorchServe .mar was unpacked into native bundle assets.",
+      "Tensor weights are stored canonically as model.safetensors; non-tensor runtime assets are stored under aux/.",
+      "The original .mar archive is not required for wrapper inference."
+    ],
+    "safetensors": {
+      "format": "safetensors",
+      "num_tensors": 297,
+      "path": "model.safetensors",
+      "roundtrip_tensor_equal": true,
+      "runtime_assets": {
+        "checkpoint_metadata": "aux/checkpoint_metadata.json",
+        "model_args": "aux/model_args.json",
+        "runtime_source_dir": "aux/graph2smiles_runtime",
+        "vocab": "aux/vocab.txt"
+      },
+      "source_member": "model.pt",
+      "status": "converted"
+    },
+    "source_format": "torchserve_mar_embedded_checkpoint",
+    "status": "converted",
+    "tool_version": "initial"
+  },
+  "display_name": "ASKCOS Retro Graph2SMILES pistachio_23Q3",
+  "embedding_supported": false,
+  "fine_tuning": {
+    "adapter_overlay_dir": "adapters",
+    "base_weights_path": "model.safetensors",
+    "notes": [
+      "This package preserves immutable base weights in model.safetensors and reserves adapters/ for future fine-tuning or LoRA overlays."
+    ]
+  },
+  "format_version": 1,
+  "generated_at": "1970-01-01T00:00:00+00:00",
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "model_id": "askcos_retro_graph2smiles",
+  "normalized_checkpoint_id": "pistachio_23q3",
+  "package_layout": {
+    "adapters_dir": "adapters",
+    "aux_dir": "aux",
+    "benchmarks_dir": "benchmarks",
+    "weights_path": "model.safetensors"
+  },
+  "source_registry_refs": [
+    {
+      "checkpoint_id": "pistachio_23q3",
+      "model_id": "askcos_retro_graph2smiles"
+    }
+  ],
+  "split_provenance": [
+    {
+      "canonical_split_family": "askcos_pistachio_23q3_split_unspecified",
+      "dataset_ref": "askcos_pistachio_23q3_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_pistachio_23q3_split_unspecified",
+      "dataset_ref": "askcos_pistachio_23q3_release",
+      "path": "modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "task_direction": "retrosynthesis",
+  "training_dataset_refs": [
+    "askcos_pistachio_23q3_release"
+  ],
+  "training_stage_bindings": [
+    {
+      "canonical_split_family": "askcos_pistachio_23q3_split_unspecified",
+      "dataset_ref": "askcos_pistachio_23q3_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_pistachio_23q3_split_unspecified",
+      "dataset_ref": "askcos_pistachio_23q3_release",
+      "path": "modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "weights": {
+    "dtype_summary": "float tensors preserved from upstream checkpoint",
+    "framework": "pytorch",
+    "path": "model.safetensors",
+    "tensor_namespace": "askcos_graph2smiles"
+  },
+  "wrapper_config": "wrapper_config.json",
+  "wrapper_family": "askcos_graph2smiles"
+}

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/provenance.json

@@ -0,0 +1,108 @@
+{
+  "conversion_notes": [
+    "The ASKCOS TorchServe .mar source archive was unpacked; model.mar is not copied into the normalized package.",
+    "Embedded tensor weights were serialized to model.safetensors and verified by safetensors round-trip equality.",
+    "Required non-tensor runtime assets such as templates, vocabularies, model args, OpenNMT metadata, and Graph2SMILES source support files are copied under aux/.",
+    "Lightweight MAR metadata is retained under aux/ for provenance only."
+  ],
+  "copied_sidecars": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/checkpoint_metadata.json",
+    "aux/graph2smiles_runtime/models/attention_xl.py",
+    "aux/graph2smiles_runtime/models/dgat.py",
+    "aux/graph2smiles_runtime/models/dgcn.py",
+    "aux/graph2smiles_runtime/models/graph2smiles.py",
+    "aux/graph2smiles_runtime/models/graphfeat.py",
+    "aux/graph2smiles_runtime/models/model_utils.py",
+    "aux/graph2smiles_runtime/models/transformer_decoder.py",
+    "aux/graph2smiles_runtime/predict.py",
+    "aux/graph2smiles_runtime/train.py",
+    "aux/graph2smiles_runtime/utils/c_calculate.so",
+    "aux/graph2smiles_runtime/utils/chem_utils.py",
+    "aux/graph2smiles_runtime/utils/ctypes_calculator.py",
+    "aux/graph2smiles_runtime/utils/data_utils.py",
+    "aux/graph2smiles_runtime/utils/parsing.py",
+    "aux/graph2smiles_runtime/utils/preprocess_utils.py",
+    "aux/graph2smiles_runtime/utils/rxn_graphs.py",
+    "aux/graph2smiles_runtime/utils/train_utils.py",
+    "aux/mar_files/handler.py",
+    "aux/mar_files/models.zip",
+    "aux/mar_files/predict.py",
+    "aux/mar_files/train.py",
+    "aux/mar_files/utils.zip",
+    "aux/mar_files/vocab.txt",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/vocab.txt"
+  ],
+  "inner_members": [
+    {
+      "archive_path": "datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "member": "models.zip",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "member": "predict.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "member": "handler.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "member": "vocab.txt",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "member": "train.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "member": "model.pt",
+      "role": "weights_source"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "member": "utils.zip",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "member": "MAR-INF/MANIFEST.json",
+      "role": "torchserve_manifest"
+    }
+  ],
+  "normalized_checkpoint_id": "pistachio_23q3",
+  "source_artifacts": [
+    {
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/pistachio_23Q3_new.mar",
+      "role": "source_artifact",
+      "sha256": "0014b36719ede8ec80cbbcf22148a7d48d65a9a0710e4474b2338ac08f744ff9",
+      "size": 200896846
+    },
+    {
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/modelos_ASKCOS/download_trained_models.sh",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/download_trained_models.sh",
+      "role": "source_artifact",
+      "sha256": "e88d26f86ce79d2c7d8f05d1a59e3b1b88bde69c3afb95d065c932ff058092be",
+      "size": 2374
+    },
+    {
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/modelos_ASKCOS/download_trained_models2.sh",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/download_trained_models2.sh",
+      "role": "source_artifact",
+      "sha256": "c2351dd12f68b0f372b23183cf470fa643f73274f66e34dfc0dacd1ce1a9843e",
+      "size": 1234
+    }
+  ]
+}

checkpoints/askcos_retro_graph2smiles/pistachio_23q3/wrapper_config.json

@@ -0,0 +1,49 @@
+{
+  "architecture_class": "Graph2SMILES",
+  "device_supported": [
+    "cpu",
+    "cuda"
+  ],
+  "fine_tuning": {
+    "adapter_overlay_dir": "adapters",
+    "base_weights_path": "model.safetensors",
+    "notes": [
+      "Base weights stay immutable in model.safetensors; future fine-tuning or LoRA adapters should be added as overlays under adapters/."
+    ]
+  },
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "license": "mit",
+  "loader": {
+    "checkpoint_metadata": "aux/checkpoint_metadata.json",
+    "kind": "askcos_graph2smiles_safetensors",
+    "model_args": "aux/model_args.json",
+    "model_version": "1.0",
+    "runtime_source_dir": "aux/graph2smiles_runtime",
+    "served_model_name": "pistachio_clean_Q3",
+    "source_handler": "handler.py",
+    "state_dict_format": "safetensors",
+    "vocab": "aux/vocab.txt"
+  },
+  "package_layout": {
+    "adapters_dir": "adapters",
+    "aux_dir": "aux",
+    "weights_path": "model.safetensors"
+  },
+  "runtime_file_map": {
+    "aux/checkpoint_metadata.json": "aux/checkpoint_metadata.json",
+    "aux/graph2smiles_runtime": "aux/graph2smiles_runtime",
+    "aux/model_args.json": "aux/model_args.json",
+    "aux/vocab.txt": "aux/vocab.txt",
+    "model.safetensors": "model.safetensors"
+  },
+  "task_direction": "retrosynthesis",
+  "wrapper_family": "askcos_graph2smiles"
+}

checkpoints/askcos_retro_graph2smiles/uspto_full/SHA256SUMS

@@ -0,0 +1,37 @@
+5a52b4f5610a621fb55c1f57ae798d713fbec01db7524b37680c9861c0954361  aux/MAR-INF/MANIFEST.json
+0c89b43faae2b20a087382c2180bc0b276b997725ed1ad474277faf32bd5edcd  aux/checkpoint_metadata.json
+b7f0a220dcbb261ea2dc3ac8e16c86a4b508cf012da5d5e250ab82c0dcbb9794  aux/graph2smiles_runtime/models/attention_xl.py
+59e5e707bf6298eaa63fccfcb638719f280579b08ccc969bb3075c2a07a9cc22  aux/graph2smiles_runtime/models/dgat.py
+0f9c77867fa1a53c18d893dab68a57f94bbaa326f8ff63e374860c45a11b1e6c  aux/graph2smiles_runtime/models/dgcn.py
+26260eb71e0da0f998d63c391641a6aa782171ed0c670c4f07014402a5073ff5  aux/graph2smiles_runtime/models/graph2smiles.py
+fbbbec61d02ddb6b9d90720b2d5b0a04a399a0abe9b1575ed4f8d428a7638f75  aux/graph2smiles_runtime/models/graphfeat.py
+3b85acd86c407470536395cf85b8af99dc067f67f31897c42dc00f4a32f772c3  aux/graph2smiles_runtime/models/model_utils.py
+d5c87645c9f7ebc96d23d3ae94c8692ffcd798e60e2b52d6d876505752eb007b  aux/graph2smiles_runtime/models/transformer_decoder.py
+9309e0352e4fb7f6c00b8dccd1bd4300ed91f7660533e3ace9db8e61645caa26  aux/graph2smiles_runtime/predict.py
+fb3b0374bcf3773e87926bce4160aa30bd9088e71b56b3daa617de2cb03892fa  aux/graph2smiles_runtime/train.py
+f7e98befeb3a532d72595f3f64728dbf32d2daa8ba91ad8e451eed16e31d244b  aux/graph2smiles_runtime/utils/c_calculate.so
+2f440d3b147d5eb16158a0eff7872bf54939a77f73d5569d229fac82f3e640d3  aux/graph2smiles_runtime/utils/chem_utils.py
+458944b4a15fb16f0da33e4e71b790815e2f88d49b5babf3b44a82d51a737422  aux/graph2smiles_runtime/utils/ctypes_calculator.py
+7a671fbff8a4c202c33af82fe2708f848a4aa07526ef7d90536ff655c77700ef  aux/graph2smiles_runtime/utils/data_utils.py
+4b2c0587180c996e160581861b8c6dae0dfde8dc8fd0f4112bb0b07704a168b4  aux/graph2smiles_runtime/utils/parsing.py
+0440ec0b6cee9da8e64b4397b83c6a1672ac3d134565c9aa7b758fd174c4fdf9  aux/graph2smiles_runtime/utils/preprocess_utils.py
+50e105d0a95fab34653c0ddc134bda5324f5825b3ce907d6349183f34d38627d  aux/graph2smiles_runtime/utils/rxn_graphs.py
+5474b2518dceaaa121aef3e4656d808d3f1dc73161eff0139277bc7f0c021ab3  aux/graph2smiles_runtime/utils/train_utils.py
+5553c34645ededd4e2012700cc0436ba54b061c3c7e97011e23b21c4eb05bfe8  aux/mar_files/handler.py
+8d1d30921e14caa8bb1a4724026436f9450cf14d532b270e867e6c59888e5d06  aux/mar_files/models.zip
+9309e0352e4fb7f6c00b8dccd1bd4300ed91f7660533e3ace9db8e61645caa26  aux/mar_files/predict.py
+fb3b0374bcf3773e87926bce4160aa30bd9088e71b56b3daa617de2cb03892fa  aux/mar_files/train.py
+55202ac5081d1a26d19a7dc55cf112b4a94762f53f06e9cded8a4a81794b0eff  aux/mar_files/utils.zip
+d345fddee01220c978ebb7eb309603eb93f729c7f16138608b4fa3601be0af3d  aux/mar_files/vocab.txt
+56cac879f4f03d2a77cd1bffcc348082da1913257daa016f434835c5cbb63058  aux/mar_members.json
+460d7fd212e36cd102514b591d81b886499780755438d47d5a62d24febd1246e  aux/model_args.json
+07c37c91ceb6a19eebabdd5b83315b7deceb4ff7c5a88dd41d76bf022c1a227c  aux/safetensors_conversion.json
+d345fddee01220c978ebb7eb309603eb93f729c7f16138608b4fa3601be0af3d  aux/vocab.txt
+89bbde98db91c67de993a5700eea47a250f1bddede31010905be22aa21ceeace  benchmarks/default_test.jsonl
+e10891de2a04dc3a7758ef20b50478c4f4285f4ac6c81f2f1ecc430e2ffb373d  benchmarks/metadata.json
+ed9665577446765da24e2552608d92aed552388c9b034bb7a03f5c2cccbb0c1b  benchmarks/native/src-test.txt
+57946e791815452a278ed93481aea629567372c79216895b30463e220b35f830  benchmarks/native/tgt-test.txt
+bdf9cd84ef69476e6104267a1325fd431143c91a12adabf47c0b8d9fb2732560  manifest.json
+76747c458b6703068a4b54fbb2c7defd7a23e60ab37fa39a97d37b3b26cc725e  model.safetensors
+9f15f2c00c40ad3b874eb810b5e339f5db51d2c327dc0bcdd808c408a01e1406  provenance.json
+cb113b97332e3586b7acc3df01d767d9976ee13044b6381171783aa45c1ca3af  wrapper_config.json

checkpoints/askcos_retro_graph2smiles/uspto_full/manifest.json

@@ -0,0 +1,168 @@
+{
+  "auxiliary_files": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/checkpoint_metadata.json",
+    "aux/graph2smiles_runtime/models/attention_xl.py",
+    "aux/graph2smiles_runtime/models/dgat.py",
+    "aux/graph2smiles_runtime/models/dgcn.py",
+    "aux/graph2smiles_runtime/models/graph2smiles.py",
+    "aux/graph2smiles_runtime/models/graphfeat.py",
+    "aux/graph2smiles_runtime/models/model_utils.py",
+    "aux/graph2smiles_runtime/models/transformer_decoder.py",
+    "aux/graph2smiles_runtime/predict.py",
+    "aux/graph2smiles_runtime/train.py",
+    "aux/graph2smiles_runtime/utils/c_calculate.so",
+    "aux/graph2smiles_runtime/utils/chem_utils.py",
+    "aux/graph2smiles_runtime/utils/ctypes_calculator.py",
+    "aux/graph2smiles_runtime/utils/data_utils.py",
+    "aux/graph2smiles_runtime/utils/parsing.py",
+    "aux/graph2smiles_runtime/utils/preprocess_utils.py",
+    "aux/graph2smiles_runtime/utils/rxn_graphs.py",
+    "aux/graph2smiles_runtime/utils/train_utils.py",
+    "aux/mar_files/handler.py",
+    "aux/mar_files/models.zip",
+    "aux/mar_files/predict.py",
+    "aux/mar_files/train.py",
+    "aux/mar_files/utils.zip",
+    "aux/mar_files/vocab.txt",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/vocab.txt",
+    "benchmarks/default_test.jsonl",
+    "benchmarks/metadata.json",
+    "benchmarks/native/src-test.txt",
+    "benchmarks/native/tgt-test.txt"
+  ],
+  "benchmark_datasets": [
+    {
+      "benchmark_variant": "askcos_uspto_full_r_smiles_compatibility_view",
+      "dataset_id": "askcos_retro_graph2smiles_uspto_full_uspto_full_test",
+      "dataset_ref": "uspto_full_gln",
+      "default": true,
+      "format": "jsonl",
+      "metadata_path": "benchmarks/metadata.json",
+      "native_input_format": "tokenized_parallel_txt",
+      "native_source_paths": [
+        "benchmarks/native/src-test.txt",
+        "benchmarks/native/tgt-test.txt"
+      ],
+      "notes": [
+        "ASKCOS does not redistribute a native USPTO-FULL benchmark CSV with this TorchServe archive in datasets/modelos_ASKCOS.",
+        "This bundle uses the public R-SMILES/GLN USPTO-FULL tokenized test split as a redistribution-safe compatibility view.",
+        "benchmarks/default_test.jsonl collapses the contiguous augmentation factor of 5 back to one benchmark case per underlying reaction."
+      ],
+      "num_examples": 96023,
+      "path": "benchmarks/default_test.jsonl",
+      "split": "test"
+    }
+  ],
+  "checkpoint_id": "uspto_full",
+  "contained_artifact_bindings": [
+    {
+      "canonical_split_family": "askcos_uspto_full_split_unspecified",
+      "dataset_ref": "askcos_uspto_full_release",
+      "path": "modelos_ASKCOS/USPTO_FULL_new.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "conversion": {
+    "converted_at": "1970-01-01T00:00:00+00:00",
+    "notes": [
+      "The upstream ASKCOS TorchServe .mar was unpacked into native bundle assets.",
+      "Tensor weights are stored canonically as model.safetensors; non-tensor runtime assets are stored under aux/.",
+      "The original .mar archive is not required for wrapper inference."
+    ],
+    "safetensors": {
+      "format": "safetensors",
+      "num_tensors": 297,
+      "path": "model.safetensors",
+      "roundtrip_tensor_equal": true,
+      "runtime_assets": {
+        "checkpoint_metadata": "aux/checkpoint_metadata.json",
+        "model_args": "aux/model_args.json",
+        "runtime_source_dir": "aux/graph2smiles_runtime",
+        "vocab": "aux/vocab.txt"
+      },
+      "source_member": "model.pt",
+      "status": "converted"
+    },
+    "source_format": "torchserve_mar_embedded_checkpoint",
+    "status": "converted",
+    "tool_version": "initial"
+  },
+  "display_name": "ASKCOS Retro Graph2SMILES USPTO_FULL",
+  "embedding_supported": false,
+  "fine_tuning": {
+    "adapter_overlay_dir": "adapters",
+    "base_weights_path": "model.safetensors",
+    "notes": [
+      "This package preserves immutable base weights in model.safetensors and reserves adapters/ for future fine-tuning or LoRA overlays."
+    ]
+  },
+  "format_version": 1,
+  "generated_at": "1970-01-01T00:00:00+00:00",
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "model_id": "askcos_retro_graph2smiles",
+  "normalized_checkpoint_id": "uspto_full",
+  "package_layout": {
+    "adapters_dir": "adapters",
+    "aux_dir": "aux",
+    "benchmarks_dir": "benchmarks",
+    "weights_path": "model.safetensors"
+  },
+  "source_registry_refs": [
+    {
+      "checkpoint_id": "uspto_full",
+      "model_id": "askcos_retro_graph2smiles"
+    }
+  ],
+  "split_provenance": [
+    {
+      "canonical_split_family": "askcos_uspto_full_split_unspecified",
+      "dataset_ref": "askcos_uspto_full_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_uspto_full_split_unspecified",
+      "dataset_ref": "askcos_uspto_full_release",
+      "path": "modelos_ASKCOS/USPTO_FULL_new.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "task_direction": "retrosynthesis",
+  "training_dataset_refs": [
+    "askcos_uspto_full_release"
+  ],
+  "training_stage_bindings": [
+    {
+      "canonical_split_family": "askcos_uspto_full_split_unspecified",
+      "dataset_ref": "askcos_uspto_full_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_uspto_full_split_unspecified",
+      "dataset_ref": "askcos_uspto_full_release",
+      "path": "modelos_ASKCOS/USPTO_FULL_new.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "weights": {
+    "dtype_summary": "float tensors preserved from upstream checkpoint",
+    "framework": "pytorch",
+    "path": "model.safetensors",
+    "tensor_namespace": "askcos_graph2smiles"
+  },
+  "wrapper_config": "wrapper_config.json",
+  "wrapper_family": "askcos_graph2smiles"
+}

checkpoints/askcos_retro_graph2smiles/uspto_full/provenance.json

@@ -0,0 +1,108 @@
+{
+  "conversion_notes": [
+    "The ASKCOS TorchServe .mar source archive was unpacked; model.mar is not copied into the normalized package.",
+    "Embedded tensor weights were serialized to model.safetensors and verified by safetensors round-trip equality.",
+    "Required non-tensor runtime assets such as templates, vocabularies, model args, OpenNMT metadata, and Graph2SMILES source support files are copied under aux/.",
+    "Lightweight MAR metadata is retained under aux/ for provenance only."
+  ],
+  "copied_sidecars": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/checkpoint_metadata.json",
+    "aux/graph2smiles_runtime/models/attention_xl.py",
+    "aux/graph2smiles_runtime/models/dgat.py",
+    "aux/graph2smiles_runtime/models/dgcn.py",
+    "aux/graph2smiles_runtime/models/graph2smiles.py",
+    "aux/graph2smiles_runtime/models/graphfeat.py",
+    "aux/graph2smiles_runtime/models/model_utils.py",
+    "aux/graph2smiles_runtime/models/transformer_decoder.py",
+    "aux/graph2smiles_runtime/predict.py",
+    "aux/graph2smiles_runtime/train.py",
+    "aux/graph2smiles_runtime/utils/c_calculate.so",
+    "aux/graph2smiles_runtime/utils/chem_utils.py",
+    "aux/graph2smiles_runtime/utils/ctypes_calculator.py",
+    "aux/graph2smiles_runtime/utils/data_utils.py",
+    "aux/graph2smiles_runtime/utils/parsing.py",
+    "aux/graph2smiles_runtime/utils/preprocess_utils.py",
+    "aux/graph2smiles_runtime/utils/rxn_graphs.py",
+    "aux/graph2smiles_runtime/utils/train_utils.py",
+    "aux/mar_files/handler.py",
+    "aux/mar_files/models.zip",
+    "aux/mar_files/predict.py",
+    "aux/mar_files/train.py",
+    "aux/mar_files/utils.zip",
+    "aux/mar_files/vocab.txt",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/vocab.txt"
+  ],
+  "inner_members": [
+    {
+      "archive_path": "datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "member": "models.zip",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "member": "predict.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "member": "handler.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "member": "vocab.txt",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "member": "train.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "member": "model.pt",
+      "role": "weights_source"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "member": "utils.zip",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "member": "MAR-INF/MANIFEST.json",
+      "role": "torchserve_manifest"
+    }
+  ],
+  "normalized_checkpoint_id": "uspto_full",
+  "source_artifacts": [
+    {
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/USPTO_FULL_new.mar",
+      "role": "source_artifact",
+      "sha256": "a59fa4e3d57a8f08a934af9c3569f07f42c052a871f0e9abccad26b3e4f0841c",
+      "size": 200532708
+    },
+    {
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/modelos_ASKCOS/download_trained_models.sh",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/download_trained_models.sh",
+      "role": "source_artifact",
+      "sha256": "e88d26f86ce79d2c7d8f05d1a59e3b1b88bde69c3afb95d065c932ff058092be",
+      "size": 2374
+    },
+    {
+      "absolute_path": "/home/ian-l/lucai/syntheseus-bundle-builder/datasets/modelos_ASKCOS/download_trained_models2.sh",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/download_trained_models2.sh",
+      "role": "source_artifact",
+      "sha256": "c2351dd12f68b0f372b23183cf470fa643f73274f66e34dfc0dacd1ce1a9843e",
+      "size": 1234
+    }
+  ]
+}

checkpoints/askcos_retro_graph2smiles/uspto_full/wrapper_config.json

@@ -0,0 +1,49 @@
+{
+  "architecture_class": "Graph2SMILES",
+  "device_supported": [
+    "cpu",
+    "cuda"
+  ],
+  "fine_tuning": {
+    "adapter_overlay_dir": "adapters",
+    "base_weights_path": "model.safetensors",
+    "notes": [
+      "Base weights stay immutable in model.safetensors; future fine-tuning or LoRA adapters should be added as overlays under adapters/."
+    ]
+  },
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "license": "mit",
+  "loader": {
+    "checkpoint_metadata": "aux/checkpoint_metadata.json",
+    "kind": "askcos_graph2smiles_safetensors",
+    "model_args": "aux/model_args.json",
+    "model_version": "1.0",
+    "runtime_source_dir": "aux/graph2smiles_runtime",
+    "served_model_name": "USPTO_full",
+    "source_handler": "handler.py",
+    "state_dict_format": "safetensors",
+    "vocab": "aux/vocab.txt"
+  },
+  "package_layout": {
+    "adapters_dir": "adapters",
+    "aux_dir": "aux",
+    "weights_path": "model.safetensors"
+  },
+  "runtime_file_map": {
+    "aux/checkpoint_metadata.json": "aux/checkpoint_metadata.json",
+    "aux/graph2smiles_runtime": "aux/graph2smiles_runtime",
+    "aux/model_args.json": "aux/model_args.json",
+    "aux/vocab.txt": "aux/vocab.txt",
+    "model.safetensors": "model.safetensors"
+  },
+  "task_direction": "retrosynthesis",
+  "wrapper_family": "askcos_graph2smiles"
+}