Add files using upload-large-folder tool

checkpoints/askcos_retro_template_relevance/bkms_metabolic/SHA256SUMS

@@ -0,0 +1,18 @@
+bf98f0614f6f04a8558f049d49a9074f269a3cfe01e2c68c4e4afd45d99a19f2  aux/MAR-INF/MANIFEST.json
+f5bef6f645347b15a1bbff2e56117d1a58f56234bdd24d89e9a18bd7a0d193d5  aux/mar_files/misc.py
+8ee17cac57f65d954a599f18bbcf9df069a1acb0be86064a21188d4f5c2171f5  aux/mar_files/models.py
+b5d99468d88374391e7ce7a1766ee287b8fbb9f1dbac70743606d43dee4f9f59  aux/mar_files/templ_rel_handler.py
+9a0d07ded45cd94abeeed5e8c1f30a1e590080b10b4bbc8314aa5e4cbc622d83  aux/mar_files/templ_rel_parser.py
+67bee61a87662e2224bb85725bdf8de048ff4ebcc934fc8ed1cdfd61186e4a4b  aux/mar_files/utils.py
+669ee3ff21dd3aede541ab5af04775f4132aea497fa233e39ddf1c09a0c74cb8  aux/mar_members.json
+040883d769a5a40d77f789aa1f99bef0eb970af96fe6822ff52251d09231ee86  aux/model_args.json
+bc047b7afb7a1a3dbaf70225560fd396eee228f106ff12f615de80dea999f8b7  aux/safetensors_conversion.json
+6ec004e43e4f37a105fa7844efb333d44c9c4f980d0988e1d96cd3b506d63578  aux/templates.jsonl
+a10255a6abd89a35d2ea48a842839f403b4b1586805c3010c0d076e0ae23754d  benchmarks/default_test.jsonl
+108fc4f1bbc3d252f30f09884c19bf279b7c513c23e73e43d5956f995cb12c86  benchmarks/metadata.json
+87d7e0013f97da27e4fd878b0598466ac07202fe131ac0f7dbdd2b423482751f  benchmarks/native/ref_routes_reaction_hashes.txt
+872533b44788754af3aa19918a04c2a508d30249d2c93eb480078cb638ad3389  benchmarks/native/selected_reactions.csv
+0749d5b4956fa1a4095e4e2026ee60cbe98fb04069d0cc870d1128320f929947  manifest.json
+63a249baa4c56dd64babc94333415fb5f384071a93f27241e5529e3efa8d9655  model.safetensors
+62a6f0a265c631d03262154ad832803a1bc46b596254c5da106a511cbef53082  provenance.json
+e2cebe6742a3ecffb2ffbf9f3889c3d082b3de876f5992150918bfd6d4bd4b72  wrapper_config.json

checkpoints/askcos_retro_template_relevance/bkms_metabolic/manifest.json

@@ -0,0 +1,138 @@
+{
+  "auxiliary_files": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl",
+    "benchmarks/default_test.jsonl",
+    "benchmarks/metadata.json",
+    "benchmarks/native/ref_routes_reaction_hashes.txt",
+    "benchmarks/native/selected_reactions.csv"
+  ],
+  "benchmark_datasets": [
+    {
+      "benchmark_variant": "askcos_paroutes_compatibility_view",
+      "dataset_id": "askcos_retro_template_relevance_bkms_metabolic_paroutes_reference_route_test",
+      "dataset_ref": "paroutes2_reference_route_reactions",
+      "default": true,
+      "format": "jsonl",
+      "metadata_path": "benchmarks/metadata.json",
+      "native_input_format": "tab_delimited_reactants_reagents_product_rows",
+      "native_source_paths": [
+        "benchmarks/native/selected_reactions.csv",
+        "benchmarks/native/ref_routes_reaction_hashes.txt"
+      ],
+      "notes": [
+        "ASKCOS does not redistribute the native train/validation/test split for this TorchServe archive in datasets/modelos_ASKCOS.",
+        "This bundled benchmark is therefore a public PaRoutes one-step retrosynthesis compatibility view, not a claim about the model's original validation split."
+      ],
+      "num_examples": 56657,
+      "path": "benchmarks/default_test.jsonl",
+      "split": "test"
+    }
+  ],
+  "checkpoint_id": "bkms_metabolic",
+  "contained_artifact_bindings": [
+    {
+      "canonical_split_family": "askcos_bkms_metabolic_split_unspecified",
+      "dataset_ref": "askcos_bkms_metabolic_release",
+      "path": "modelos_ASKCOS/mars/bkms_metabolic.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": 4,
+      "path": "model.safetensors",
+      "roundtrip_tensor_equal": true,
+      "runtime_assets": {
+        "model_args": "aux/model_args.json",
+        "templates": "aux/templates.jsonl"
+      },
+      "source_member": "model_latest.pt",
+      "status": "converted"
+    },
+    "source_format": "torchserve_mar_embedded_checkpoint",
+    "status": "converted",
+    "tool_version": "initial"
+  },
+  "display_name": "bkms_metabolic",
+  "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_template_relevance",
+  "model_role": "backward",
+  "normalized_checkpoint_id": "bkms_metabolic",
+  "package_layout": {
+    "aux_dir": "aux",
+    "benchmarks_dir": "benchmarks",
+    "weights_path": "model.safetensors"
+  },
+  "source_registry_refs": [
+    {
+      "checkpoint_id": "bkms_metabolic",
+      "model_id": "askcos_retro_template_relevance"
+    }
+  ],
+  "split_provenance": [
+    {
+      "canonical_split_family": "askcos_bkms_metabolic_split_unspecified",
+      "dataset_ref": "askcos_bkms_metabolic_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_bkms_metabolic_split_unspecified",
+      "dataset_ref": "askcos_bkms_metabolic_release",
+      "path": "modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "task_direction": "retrosynthesis",
+  "training_dataset_refs": [
+    "askcos_bkms_metabolic_release"
+  ],
+  "training_stage_bindings": [
+    {
+      "canonical_split_family": "askcos_bkms_metabolic_split_unspecified",
+      "dataset_ref": "askcos_bkms_metabolic_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_bkms_metabolic_split_unspecified",
+      "dataset_ref": "askcos_bkms_metabolic_release",
+      "path": "modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "weights": {
+    "dtype_summary": "float tensors preserved from upstream checkpoint",
+    "framework": "safetensors",
+    "path": "model.safetensors",
+    "tensor_namespace": "askcos_template_relevance"
+  },
+  "wrapper_config": "wrapper_config.json",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/bkms_metabolic/provenance.json

@@ -0,0 +1,89 @@
+{
+  "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/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl"
+  ],
+  "inner_members": [
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "member": "templates.jsonl",
+      "role": "template_library"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "member": "misc.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "member": "utils.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "member": "models.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "member": "model_latest.pt",
+      "role": "weights_source"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "member": "templ_rel_parser.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "member": "templ_rel_handler.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "member": "MAR-INF/MANIFEST.json",
+      "role": "torchserve_manifest"
+    }
+  ],
+  "normalized_checkpoint_id": "bkms_metabolic",
+  "source_artifacts": [
+    {
+      "absolute_path": "/mnt/HDD/syntheseus-bundle-builder/datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/mars/bkms_metabolic.mar",
+      "role": "source_artifact",
+      "sha256": "67f22c093dfb8a6fa24952c2c7f1cf527e45c15a6557ae8c21a446a91eae51d2",
+      "size": 152935700
+    },
+    {
+      "absolute_path": "/mnt/HDD/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": "/mnt/HDD/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_template_relevance/bkms_metabolic/wrapper_config.json

@@ -0,0 +1,37 @@
+{
+  "architecture_class": "NeuralSym-style template relevance FFN",
+  "device_supported": [
+    "cpu",
+    "cuda"
+  ],
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "license": "mit",
+  "loader": {
+    "kind": "askcos_template_relevance_safetensors",
+    "model_args": "aux/model_args.json",
+    "model_version": "1.0",
+    "served_model_name": "bkms_metabolic",
+    "source_handler": "templ_rel_handler.py",
+    "state_dict_format": "safetensors",
+    "templates": "aux/templates.jsonl"
+  },
+  "package_layout": {
+    "aux_dir": "aux",
+    "weights_path": "model.safetensors"
+  },
+  "runtime_file_map": {
+    "aux/model_args.json": "aux/model_args.json",
+    "aux/templates.jsonl": "aux/templates.jsonl",
+    "model.safetensors": "model.safetensors"
+  },
+  "task_direction": "retrosynthesis",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/pistachio/SHA256SUMS

@@ -0,0 +1,18 @@
+e04658a41a9c75a797dc18e2d141db8ed9e3ae37261eb6302b6b3e59993fb40a  aux/MAR-INF/MANIFEST.json
+f5bef6f645347b15a1bbff2e56117d1a58f56234bdd24d89e9a18bd7a0d193d5  aux/mar_files/misc.py
+8ee17cac57f65d954a599f18bbcf9df069a1acb0be86064a21188d4f5c2171f5  aux/mar_files/models.py
+b5d99468d88374391e7ce7a1766ee287b8fbb9f1dbac70743606d43dee4f9f59  aux/mar_files/templ_rel_handler.py
+9a0d07ded45cd94abeeed5e8c1f30a1e590080b10b4bbc8314aa5e4cbc622d83  aux/mar_files/templ_rel_parser.py
+67bee61a87662e2224bb85725bdf8de048ff4ebcc934fc8ed1cdfd61186e4a4b  aux/mar_files/utils.py
+21150e0de739e16d25ea2bff971b6658bc5791edeb23ac66dbb3a67bd4135191  aux/mar_members.json
+8f52f6da6d2c8f9625d2254a2ef864524c966b6a166a5bcc0e00d1ff874f076e  aux/model_args.json
+bc047b7afb7a1a3dbaf70225560fd396eee228f106ff12f615de80dea999f8b7  aux/safetensors_conversion.json
+1df1c91b2fef57dfcfa062139fb9067f02657dfcc1829c4daceef47d43610a2a  aux/templates.jsonl
+a10255a6abd89a35d2ea48a842839f403b4b1586805c3010c0d076e0ae23754d  benchmarks/default_test.jsonl
+68ddd00c0d52c9f10b97e4a4802f2a68f8dbc44e56a03946634a025279a1aa84  benchmarks/metadata.json
+87d7e0013f97da27e4fd878b0598466ac07202fe131ac0f7dbdd2b423482751f  benchmarks/native/ref_routes_reaction_hashes.txt
+872533b44788754af3aa19918a04c2a508d30249d2c93eb480078cb638ad3389  benchmarks/native/selected_reactions.csv
+cc17e3d9b2a4b0615a2f057fdaf48b77c6cd0df74b004963cd4f0289f5df0e1a  manifest.json
+7051c63a9ad64cb85ff00a43f5bfc65f2fe55f2165464b59a68c2415ed695115  model.safetensors
+13ea4891403671d66358c56574e1d1d4bf023927c5167a63a30064864ed08cf6  provenance.json
+b29f4070b36e8c8b5af44635efb8d6d8a59912d6d86836a2a97dba2c24cc3431  wrapper_config.json

checkpoints/askcos_retro_template_relevance/pistachio/manifest.json

@@ -0,0 +1,138 @@
+{
+  "auxiliary_files": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl",
+    "benchmarks/default_test.jsonl",
+    "benchmarks/metadata.json",
+    "benchmarks/native/ref_routes_reaction_hashes.txt",
+    "benchmarks/native/selected_reactions.csv"
+  ],
+  "benchmark_datasets": [
+    {
+      "benchmark_variant": "askcos_paroutes_compatibility_view",
+      "dataset_id": "askcos_retro_template_relevance_pistachio_paroutes_reference_route_test",
+      "dataset_ref": "paroutes2_reference_route_reactions",
+      "default": true,
+      "format": "jsonl",
+      "metadata_path": "benchmarks/metadata.json",
+      "native_input_format": "tab_delimited_reactants_reagents_product_rows",
+      "native_source_paths": [
+        "benchmarks/native/selected_reactions.csv",
+        "benchmarks/native/ref_routes_reaction_hashes.txt"
+      ],
+      "notes": [
+        "ASKCOS does not redistribute the native train/validation/test split for this TorchServe archive in datasets/modelos_ASKCOS.",
+        "This bundled benchmark is therefore a public PaRoutes one-step retrosynthesis compatibility view, not a claim about the model's original validation split."
+      ],
+      "num_examples": 56657,
+      "path": "benchmarks/default_test.jsonl",
+      "split": "test"
+    }
+  ],
+  "checkpoint_id": "pistachio",
+  "contained_artifact_bindings": [
+    {
+      "canonical_split_family": "askcos_pistachio_split_unspecified",
+      "dataset_ref": "askcos_pistachio_release",
+      "path": "modelos_ASKCOS/mars/pistachio.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": 4,
+      "path": "model.safetensors",
+      "roundtrip_tensor_equal": true,
+      "runtime_assets": {
+        "model_args": "aux/model_args.json",
+        "templates": "aux/templates.jsonl"
+      },
+      "source_member": "model_latest.pt",
+      "status": "converted"
+    },
+    "source_format": "torchserve_mar_embedded_checkpoint",
+    "status": "converted",
+    "tool_version": "initial"
+  },
+  "display_name": "pistachio",
+  "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_template_relevance",
+  "model_role": "backward",
+  "normalized_checkpoint_id": "pistachio",
+  "package_layout": {
+    "aux_dir": "aux",
+    "benchmarks_dir": "benchmarks",
+    "weights_path": "model.safetensors"
+  },
+  "source_registry_refs": [
+    {
+      "checkpoint_id": "pistachio",
+      "model_id": "askcos_retro_template_relevance"
+    }
+  ],
+  "split_provenance": [
+    {
+      "canonical_split_family": "askcos_pistachio_split_unspecified",
+      "dataset_ref": "askcos_pistachio_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_pistachio_split_unspecified",
+      "dataset_ref": "askcos_pistachio_release",
+      "path": "modelos_ASKCOS/mars/pistachio.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "task_direction": "retrosynthesis",
+  "training_dataset_refs": [
+    "askcos_pistachio_release"
+  ],
+  "training_stage_bindings": [
+    {
+      "canonical_split_family": "askcos_pistachio_split_unspecified",
+      "dataset_ref": "askcos_pistachio_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_pistachio_split_unspecified",
+      "dataset_ref": "askcos_pistachio_release",
+      "path": "modelos_ASKCOS/mars/pistachio.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "weights": {
+    "dtype_summary": "float tensors preserved from upstream checkpoint",
+    "framework": "safetensors",
+    "path": "model.safetensors",
+    "tensor_namespace": "askcos_template_relevance"
+  },
+  "wrapper_config": "wrapper_config.json",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/pistachio/provenance.json

@@ -0,0 +1,89 @@
+{
+  "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/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl"
+  ],
+  "inner_members": [
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "member": "templates.jsonl",
+      "role": "template_library"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "member": "misc.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "member": "utils.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "member": "models.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "member": "model_latest.pt",
+      "role": "weights_source"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "member": "templ_rel_parser.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "member": "templ_rel_handler.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "member": "MAR-INF/MANIFEST.json",
+      "role": "torchserve_manifest"
+    }
+  ],
+  "normalized_checkpoint_id": "pistachio",
+  "source_artifacts": [
+    {
+      "absolute_path": "/mnt/HDD/syntheseus-bundle-builder/datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/mars/pistachio.mar",
+      "role": "source_artifact",
+      "sha256": "9de0e67eda18a34a311d1f8311ae2d914503db92900232cec1eeeeb7d28ace9b",
+      "size": 800751502
+    },
+    {
+      "absolute_path": "/mnt/HDD/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": "/mnt/HDD/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_template_relevance/pistachio/wrapper_config.json

@@ -0,0 +1,37 @@
+{
+  "architecture_class": "NeuralSym-style template relevance FFN",
+  "device_supported": [
+    "cpu",
+    "cuda"
+  ],
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "license": "mit",
+  "loader": {
+    "kind": "askcos_template_relevance_safetensors",
+    "model_args": "aux/model_args.json",
+    "model_version": "1.0",
+    "served_model_name": "pistachio",
+    "source_handler": "templ_rel_handler.py",
+    "state_dict_format": "safetensors",
+    "templates": "aux/templates.jsonl"
+  },
+  "package_layout": {
+    "aux_dir": "aux",
+    "weights_path": "model.safetensors"
+  },
+  "runtime_file_map": {
+    "aux/model_args.json": "aux/model_args.json",
+    "aux/templates.jsonl": "aux/templates.jsonl",
+    "model.safetensors": "model.safetensors"
+  },
+  "task_direction": "retrosynthesis",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/pistachio_ringbreaker/SHA256SUMS

@@ -0,0 +1,18 @@
+4afef999655ed2ee022510e7211614c066414bdcb178bab2fb347af3726da5d8  aux/MAR-INF/MANIFEST.json
+f5bef6f645347b15a1bbff2e56117d1a58f56234bdd24d89e9a18bd7a0d193d5  aux/mar_files/misc.py
+8ee17cac57f65d954a599f18bbcf9df069a1acb0be86064a21188d4f5c2171f5  aux/mar_files/models.py
+b5d99468d88374391e7ce7a1766ee287b8fbb9f1dbac70743606d43dee4f9f59  aux/mar_files/templ_rel_handler.py
+9a0d07ded45cd94abeeed5e8c1f30a1e590080b10b4bbc8314aa5e4cbc622d83  aux/mar_files/templ_rel_parser.py
+67bee61a87662e2224bb85725bdf8de048ff4ebcc934fc8ed1cdfd61186e4a4b  aux/mar_files/utils.py
+3247db61ca9acb4c96eeb103abc68f93981269ed23db0be3bf34ab5a69d6e58b  aux/mar_members.json
+cc62c4532aff590fd3ef222a3c1a6e9b3b70e10dd1f199d4f0dd405127c3bc02  aux/model_args.json
+bc047b7afb7a1a3dbaf70225560fd396eee228f106ff12f615de80dea999f8b7  aux/safetensors_conversion.json
+5fe58b0472aac4ea508d401116705e0f2795f8c43c8726486f98a06985f49edb  aux/templates.jsonl
+a10255a6abd89a35d2ea48a842839f403b4b1586805c3010c0d076e0ae23754d  benchmarks/default_test.jsonl
+818b98cb596a3712b8eb192612b6b524c217f653d90ec26a8df25e356cdfd8ad  benchmarks/metadata.json
+87d7e0013f97da27e4fd878b0598466ac07202fe131ac0f7dbdd2b423482751f  benchmarks/native/ref_routes_reaction_hashes.txt
+872533b44788754af3aa19918a04c2a508d30249d2c93eb480078cb638ad3389  benchmarks/native/selected_reactions.csv
+04d1f5ab53afff49ee6e0934a588d1c1d7b12afdc53da571303f8973bbec760a  manifest.json
+d7d0e725423a089059964d9c34e7f6e301a9c8bc22d3f0be6f0976aabb5425aa  model.safetensors
+d068b06b4e1cf8feb80c34364ddd7b35006249e95b530959d983d73dc3efe6c8  provenance.json
+67740d56186a83f70de1fba6f10f3eb7d8869f638fb18c8507c6c95e030a278a  wrapper_config.json

checkpoints/askcos_retro_template_relevance/pistachio_ringbreaker/aux/mar_members.json

@@ -0,0 +1,52 @@
+{
+  "members": [
+    {
+      "compress_size": 2553981,
+      "modified": "2023-07-07T04:16:08",
+      "path": "templates.jsonl",
+      "size": 17047890
+    },
+    {
+      "compress_size": 441,
+      "modified": "2023-07-11T20:38:48",
+      "path": "misc.py",
+      "size": 1062
+    },
+    {
+      "compress_size": 2113,
+      "modified": "2023-09-17T00:40:16",
+      "path": "utils.py",
+      "size": 6591
+    },
+    {
+      "compress_size": 1249,
+      "modified": "2023-07-11T20:38:48",
+      "path": "models.py",
+      "size": 4027
+    },
+    {
+      "compress_size": 128374269,
+      "modified": "2023-07-07T04:16:08",
+      "path": "model_latest.pt",
+      "size": 141616535
+    },
+    {
+      "compress_size": 992,
+      "modified": "2023-09-16T23:59:50",
+      "path": "templ_rel_parser.py",
+      "size": 4119
+    },
+    {
+      "compress_size": 2524,
+      "modified": "2023-09-17T00:43:56",
+      "path": "templ_rel_handler.py",
+      "size": 8685
+    },
+    {
+      "compress_size": 151,
+      "modified": "2023-09-17T00:44:00",
+      "path": "MAR-INF/MANIFEST.json",
+      "size": 218
+    }
+  ]
+}

checkpoints/askcos_retro_template_relevance/pistachio_ringbreaker/aux/model_args.json

@@ -0,0 +1,20 @@
+{
+  "dropout": 0.1,
+  "fp_size": 2048,
+  "gating_activation": "sigmoid",
+  "hidden_activation": "relu",
+  "hidden_sizes": [
+    1024
+  ],
+  "load_from": "",
+  "min_freq": 1,
+  "model_ckpt_new": "./tmp/legacy_v2/pistachio_ringbreaker.pt",
+  "model_folder_old": "./tmp/legacy_v1/pistachio_ringbreaker/1",
+  "n_params": 35403501,
+  "n_templates": 32493,
+  "num_cores": 4,
+  "radius": 2,
+  "skip_connection": "none",
+  "template_file_new": "./tmp/legacy_v2/retro.templates.pistachio_ringbreaker.jsonl",
+  "template_file_old": "./tmp/legacy_v1/retro.templates.pistachio_ringbreaker.json.gz"
+}

checkpoints/askcos_retro_template_relevance/pistachio_ringbreaker/aux/safetensors_conversion.json

@@ -0,0 +1,12 @@
+{
+  "format": "safetensors",
+  "num_tensors": 4,
+  "path": "model.safetensors",
+  "roundtrip_tensor_equal": true,
+  "runtime_assets": {
+    "model_args": "aux/model_args.json",
+    "templates": "aux/templates.jsonl"
+  },
+  "source_member": "model_latest.pt",
+  "status": "converted"
+}

checkpoints/askcos_retro_template_relevance/pistachio_ringbreaker/benchmarks/metadata.json

@@ -0,0 +1,32 @@
+{
+  "benchmark_variant": "askcos_paroutes_compatibility_view",
+  "built_at": "1970-01-01T00:00:00+00:00",
+  "checkpoint_id": "pistachio_ringbreaker",
+  "dataset_id": "askcos_retro_template_relevance_pistachio_ringbreaker_paroutes_reference_route_test",
+  "dataset_ref": "paroutes2_reference_route_reactions",
+  "native_input_format": "tab_delimited_reactants_reagents_product_rows",
+  "native_sources": [
+    {
+      "notes": [
+        "Public PaRoutes selected_reactions.csv source table used to reconstruct the one-step reference-route reaction subset."
+      ],
+      "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"
+    },
+    {
+      "notes": [
+        "Public PaRoutes hash list identifying the reference-route reactions used here as a redistribution-safe ASKCOS compatibility benchmark."
+      ],
+      "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"
+    }
+  ],
+  "notes": [
+    "ASKCOS does not redistribute the native train/validation/test split for this TorchServe archive in datasets/modelos_ASKCOS.",
+    "This bundled benchmark is therefore a public PaRoutes one-step retrosynthesis compatibility view, not a claim about the model's original validation split."
+  ],
+  "num_examples": 56657,
+  "split": "test"
+}

checkpoints/askcos_retro_template_relevance/pistachio_ringbreaker/manifest.json

@@ -0,0 +1,138 @@
+{
+  "auxiliary_files": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl",
+    "benchmarks/default_test.jsonl",
+    "benchmarks/metadata.json",
+    "benchmarks/native/ref_routes_reaction_hashes.txt",
+    "benchmarks/native/selected_reactions.csv"
+  ],
+  "benchmark_datasets": [
+    {
+      "benchmark_variant": "askcos_paroutes_compatibility_view",
+      "dataset_id": "askcos_retro_template_relevance_pistachio_ringbreaker_paroutes_reference_route_test",
+      "dataset_ref": "paroutes2_reference_route_reactions",
+      "default": true,
+      "format": "jsonl",
+      "metadata_path": "benchmarks/metadata.json",
+      "native_input_format": "tab_delimited_reactants_reagents_product_rows",
+      "native_source_paths": [
+        "benchmarks/native/selected_reactions.csv",
+        "benchmarks/native/ref_routes_reaction_hashes.txt"
+      ],
+      "notes": [
+        "ASKCOS does not redistribute the native train/validation/test split for this TorchServe archive in datasets/modelos_ASKCOS.",
+        "This bundled benchmark is therefore a public PaRoutes one-step retrosynthesis compatibility view, not a claim about the model's original validation split."
+      ],
+      "num_examples": 56657,
+      "path": "benchmarks/default_test.jsonl",
+      "split": "test"
+    }
+  ],
+  "checkpoint_id": "pistachio_ringbreaker",
+  "contained_artifact_bindings": [
+    {
+      "canonical_split_family": "askcos_pistachio_ringbreaker_split_unspecified",
+      "dataset_ref": "askcos_pistachio_ringbreaker_release",
+      "path": "modelos_ASKCOS/mars/pistachio_ringbreaker.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": 4,
+      "path": "model.safetensors",
+      "roundtrip_tensor_equal": true,
+      "runtime_assets": {
+        "model_args": "aux/model_args.json",
+        "templates": "aux/templates.jsonl"
+      },
+      "source_member": "model_latest.pt",
+      "status": "converted"
+    },
+    "source_format": "torchserve_mar_embedded_checkpoint",
+    "status": "converted",
+    "tool_version": "initial"
+  },
+  "display_name": "pistachio_ringbreaker",
+  "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_template_relevance",
+  "model_role": "backward",
+  "normalized_checkpoint_id": "pistachio_ringbreaker",
+  "package_layout": {
+    "aux_dir": "aux",
+    "benchmarks_dir": "benchmarks",
+    "weights_path": "model.safetensors"
+  },
+  "source_registry_refs": [
+    {
+      "checkpoint_id": "pistachio_ringbreaker",
+      "model_id": "askcos_retro_template_relevance"
+    }
+  ],
+  "split_provenance": [
+    {
+      "canonical_split_family": "askcos_pistachio_ringbreaker_split_unspecified",
+      "dataset_ref": "askcos_pistachio_ringbreaker_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_pistachio_ringbreaker_split_unspecified",
+      "dataset_ref": "askcos_pistachio_ringbreaker_release",
+      "path": "modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "task_direction": "retrosynthesis",
+  "training_dataset_refs": [
+    "askcos_pistachio_ringbreaker_release"
+  ],
+  "training_stage_bindings": [
+    {
+      "canonical_split_family": "askcos_pistachio_ringbreaker_split_unspecified",
+      "dataset_ref": "askcos_pistachio_ringbreaker_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_pistachio_ringbreaker_split_unspecified",
+      "dataset_ref": "askcos_pistachio_ringbreaker_release",
+      "path": "modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "weights": {
+    "dtype_summary": "float tensors preserved from upstream checkpoint",
+    "framework": "safetensors",
+    "path": "model.safetensors",
+    "tensor_namespace": "askcos_template_relevance"
+  },
+  "wrapper_config": "wrapper_config.json",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/pistachio_ringbreaker/provenance.json

@@ -0,0 +1,89 @@
+{
+  "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/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl"
+  ],
+  "inner_members": [
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "member": "templates.jsonl",
+      "role": "template_library"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "member": "misc.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "member": "utils.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "member": "models.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "member": "model_latest.pt",
+      "role": "weights_source"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "member": "templ_rel_parser.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "member": "templ_rel_handler.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "member": "MAR-INF/MANIFEST.json",
+      "role": "torchserve_manifest"
+    }
+  ],
+  "normalized_checkpoint_id": "pistachio_ringbreaker",
+  "source_artifacts": [
+    {
+      "absolute_path": "/mnt/HDD/syntheseus-bundle-builder/datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/mars/pistachio_ringbreaker.mar",
+      "role": "source_artifact",
+      "sha256": "f9235d0a2df9730d8d119df01252d4f5f360bd999926112f6a37fbaa96e023ab",
+      "size": 130936578
+    },
+    {
+      "absolute_path": "/mnt/HDD/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": "/mnt/HDD/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_template_relevance/pistachio_ringbreaker/wrapper_config.json

@@ -0,0 +1,37 @@
+{
+  "architecture_class": "NeuralSym-style template relevance FFN",
+  "device_supported": [
+    "cpu",
+    "cuda"
+  ],
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "license": "mit",
+  "loader": {
+    "kind": "askcos_template_relevance_safetensors",
+    "model_args": "aux/model_args.json",
+    "model_version": "1.0",
+    "served_model_name": "pistachio_ringbreaker",
+    "source_handler": "templ_rel_handler.py",
+    "state_dict_format": "safetensors",
+    "templates": "aux/templates.jsonl"
+  },
+  "package_layout": {
+    "aux_dir": "aux",
+    "weights_path": "model.safetensors"
+  },
+  "runtime_file_map": {
+    "aux/model_args.json": "aux/model_args.json",
+    "aux/templates.jsonl": "aux/templates.jsonl",
+    "model.safetensors": "model.safetensors"
+  },
+  "task_direction": "retrosynthesis",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/reaxys/SHA256SUMS

@@ -0,0 +1,18 @@
+ffa111d011edf3ba7b91976b6d659691efe28435e4df0673be5aff9cd0b79cc7  aux/MAR-INF/MANIFEST.json
+f5bef6f645347b15a1bbff2e56117d1a58f56234bdd24d89e9a18bd7a0d193d5  aux/mar_files/misc.py
+8ee17cac57f65d954a599f18bbcf9df069a1acb0be86064a21188d4f5c2171f5  aux/mar_files/models.py
+b5d99468d88374391e7ce7a1766ee287b8fbb9f1dbac70743606d43dee4f9f59  aux/mar_files/templ_rel_handler.py
+9a0d07ded45cd94abeeed5e8c1f30a1e590080b10b4bbc8314aa5e4cbc622d83  aux/mar_files/templ_rel_parser.py
+67bee61a87662e2224bb85725bdf8de048ff4ebcc934fc8ed1cdfd61186e4a4b  aux/mar_files/utils.py
+ac56f2d92d520d3d9c03c0e2ab09051dcce5230549d2023b843767743d0ad72a  aux/mar_members.json
+3b1a4832e0e44c3bcb68483efa97a712dfcc926cacdae8b6aab87812e6d31b1e  aux/model_args.json
+3a9b5596e16ef91b405c674138426ebb61d32d2b308f59d4211c804791b66d36  aux/safetensors_conversion.json
+6a7983b86edc7164ee4fccb814598cdc311049d9815e29e981462967f4670501  aux/templates.jsonl
+a10255a6abd89a35d2ea48a842839f403b4b1586805c3010c0d076e0ae23754d  benchmarks/default_test.jsonl
+d04f29c0d724337f6491272215238fa1b1e4a06d8b351f9dc7e9b0657e999860  benchmarks/metadata.json
+87d7e0013f97da27e4fd878b0598466ac07202fe131ac0f7dbdd2b423482751f  benchmarks/native/ref_routes_reaction_hashes.txt
+872533b44788754af3aa19918a04c2a508d30249d2c93eb480078cb638ad3389  benchmarks/native/selected_reactions.csv
+c391d2a8e52552add8b48d9572559a17e939efabcc67d68ea8612f4399d58ae4  manifest.json
+834cddcb66580a3c26377ee996f93f780e24530ca9076f518a3bd53714be412e  model.safetensors
+0f6d6b8b9e9786e20270075294013fd6128902546b5bbfbc7d0312c4dd95698e  provenance.json
+f3f242bafa0df363d26499bb4e72f3a401678e48f1667c4ed3628e058d87251d  wrapper_config.json

checkpoints/askcos_retro_template_relevance/reaxys/aux/MAR-INF/MANIFEST.json

@@ -0,0 +1,10 @@
+{
+  "archiverVersion": "0.3.1",
+  "createdOn": "17/09/2023 00:44:01",
+  "model": {
+    "handler": "templ_rel_handler.py",
+    "modelName": "reaxys",
+    "modelVersion": "1.0"
+  },
+  "runtime": "python"
+}

checkpoints/askcos_retro_template_relevance/reaxys/aux/mar_files/misc.py

@@ -0,0 +1,45 @@
+import logging
+import os
+import sys
+import torch
+
+
+class BlockPrint:
+    """Context manager to suppress printing from subprocesses"""
+    def __enter__(self):
+        self._original_stdout = sys.stdout
+        sys.stdout = open(os.devnull, 'w')
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        sys.stdout.close()
+        sys.stdout = self._original_stdout
+
+
+def log_args(args, message: str):
+    log_rank_0(message)
+    for k, v in vars(args).items():
+        log_rank_0(f"**** {k} = *{v}*")
+
+
+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 setup_logger(log_file):
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+
+    fh = logging.FileHandler(log_file)
+    sh = logging.StreamHandler(sys.stdout)
+    fh.setLevel(logging.INFO)
+    sh.setLevel(logging.INFO)
+    logger.addHandler(fh)
+    logger.addHandler(sh)
+
+    return logger

checkpoints/askcos_retro_template_relevance/reaxys/aux/mar_files/models.py

@@ -0,0 +1,119 @@
+import torch
+import torch.nn as nn
+from typing import Tuple
+
+
+def get_activation(name: str) -> nn.Module:
+    _activations = {
+        "relu": nn.ReLU(),
+        "elu": nn.ELU(),
+        "gelu": nn.GELU(),
+        "leakyrelu": nn.LeakyReLU(),
+        "sigmoid": nn.Sigmoid(),
+        "tanh": nn.Tanh()
+    }
+
+    return _activations[name]
+
+
+class Dense(nn.Module):
+    def __init__(self, in_features: int, out_features: int,
+                 hidden_act: nn.Module):
+        super().__init__()
+        self.linear = nn.Linear(in_features, out_features, bias=True)
+        self.hidden_act = hidden_act
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.hidden_act(self.linear(x))
+
+
+class Highway(nn.Module):
+    def __init__(self, in_features: int, out_features: int,
+                 hidden_act: nn.Module, gating_act: nn.Module):
+        super().__init__()
+        self.dense = nn.Linear(in_features, out_features, bias=True)
+        self.gate = nn.Linear(in_features, out_features, bias=True)
+        self.hidden_act = hidden_act
+        self.gating_act = gating_act
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        transform = self.hidden_act(self.dense(x))
+        transform_gate = self.gating_act(self.gate(x))
+        carry_gate = 1 - transform_gate
+        output = transform * transform_gate + x * carry_gate
+
+        return output
+
+
+class TemplRel(nn.Module):
+    def __init__(self, args):
+        super().__init__()
+
+        if isinstance(args.hidden_sizes, str):
+            args.hidden_sizes = [int(size) for size in args.hidden_sizes.split(",")]
+
+        self.args = args
+        self.layers = self._build_layers(args)
+        self.output_layer = nn.Linear(
+            args.hidden_sizes[-1], args.n_templates, bias=True)
+
+        # we will do all the dropout here in TemplRel, for backward compatibility
+        self.dropout = nn.Dropout(args.dropout)
+        self.criterion = nn.CrossEntropyLoss(ignore_index=-1, reduction="mean")
+
+    @staticmethod
+    def _build_layers(args) -> nn.ModuleList:
+        hidden_act = get_activation(args.hidden_activation)
+        # input projection layer; no skip connection here
+        layers = nn.ModuleList([
+            Dense(args.fp_size, args.hidden_sizes[0], hidden_act=hidden_act)
+        ])
+
+        for layer_i in range(len(args.hidden_sizes) - 1):
+            in_features = args.hidden_sizes[layer_i]
+            out_features = args.hidden_sizes[layer_i + 1]
+
+            if args.skip_connection == "none":
+                layer = Dense(in_features, out_features, hidden_act=hidden_act)
+            elif args.skip_connection == "highway":
+                layer = Highway(
+                    in_features,
+                    out_features,
+                    hidden_act=hidden_act,
+                    gating_act=get_activation(args.gating_activation)
+                )
+            else:
+                raise ValueError(
+                    f"Unsupported skip_connection: {args.skip_connection}"
+                )
+
+            layers.append(layer)
+
+        return layers
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        for layer in self.layers:
+            x = layer(x)
+            x = self.dropout(x)
+
+        logits = self.output_layer(x)           # returning *unnormalized* logits
+
+        return logits
+
+    def get_loss(self, logits: torch.Tensor, target: torch.Tensor
+                 ) -> Tuple[torch.Tensor, torch.Tensor]:
+        loss = self.criterion(input=logits, target=target)
+
+        predictions = torch.argmax(logits, dim=1)
+        accs = (predictions == target).float()
+        acc = accs.mean()
+
+        # Data points with label -1 (no/failed templates) should really be treated as
+        # if they are predicted wrong. Therefore, we turned off the masking. This may
+        # noticeably decrease the computed accuracy, but would reflect the reality.
+
+        # mask = (target != -1).long()
+        # accs = accs * mask
+        # acc = accs.sum() / mask.sum()
+
+        return loss, acc

checkpoints/askcos_retro_template_relevance/reaxys/aux/mar_files/templ_rel_handler.py

@@ -0,0 +1,201 @@
+import argparse
+import glob
+import numpy as np
+import os
+import templ_rel_parser
+import torch
+import torch.nn.functional as F
+from utils import canonicalize_smiles
+from rdchiral.initialization import rdchiralReactants, rdchiralReaction
+from rdchiral.main import rdchiralRun
+from typing import Any, Dict, List, Tuple
+from utils import get_model, load_templates_as_list, mol_smi_to_count_fp
+
+
+class TemplRelHandler:
+    """TemplRel Handler for use with torchserve"""
+
+    def __init__(self):
+        self._context = None
+        self.manifest = None
+        self.initialized = False
+
+        self.args = None
+        self.templates = None
+        self.template_attributes = None
+        self.model = None
+        self.indices = None
+        self.device = None
+
+    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")
+
+        serve_parser = argparse.ArgumentParser("serve")
+        templ_rel_parser.add_predict_opts(serve_parser)
+        self.args, _ = serve_parser.parse_known_args()
+
+        template_file = os.path.join(model_dir, "templates.jsonl")
+        print(f"Loading templates and attributes from {template_file}")
+        self.templates, self.template_attributes = \
+            load_templates_as_list(template_file=template_file)
+        print(f'Total number of templates: {len(self.templates)}')
+
+        checkpoint_file = os.path.join(model_dir, "model_latest.pt")
+        print(f"Building model and loading from {checkpoint_file}")
+
+        self.args.load_from = checkpoint_file
+        self.args.local_rank = -1
+        # Note: the model will be built using pretraining args
+        self.model, _ = get_model(self.args, device=self.device)
+        self.model.eval()
+
+        self.initialized = True
+
+    def preprocess(self, data: List[dict]
+                   ) -> Tuple[List[str], int, float, List[Dict[str, Any]]]:
+        print(f"input: {data}")
+        canonical_smiles = [canonicalize_smiles(smi)
+                            for smi in data[0]["body"]["smiles"]]
+        max_num_templates = data[0]["body"].get("max_num_templates", 1000)
+        max_cum_prob = data[0]["body"].get("max_cum_prob", 0.999)
+        attribute_filter = data[0]["body"].get("attribute_filter", [])
+
+        return canonical_smiles, max_num_templates, max_cum_prob, attribute_filter
+
+    def inference(self, inputs: Tuple[List[str], int, float, List[Dict[str, Any]]]
+                  ) -> List[Dict[str, Any]]:
+        canonical_smiles, max_num_templates, max_cum_prob, attribute_filter = inputs
+        filters = [x for x in attribute_filter
+                   if x.get("name") in self.template_attributes]
+
+        if filters:
+            filter_query = " and ".join(
+                [f"({q['name']} {q['logic']} {q['value']})" for q in filters]
+            )
+            filtered_indices = self.template_attributes.query(filter_query).index.values
+
+        results = []
+
+        # maybe not the most efficient way, but should have been faster than v1 already
+        with torch.no_grad():
+            for smi in canonical_smiles:
+                prod_fp = mol_smi_to_count_fp(smi, self.args.radius, self.args.fp_size)
+                final_fp = torch.as_tensor(prod_fp.toarray()).float().to(self.device)
+
+                # template_prioritizer.predict()
+                logits = self.model(final_fp)
+                scores = F.softmax(logits, dim=1)
+                scores = scores.squeeze(dim=0).cpu().numpy()
+                indices = np.argsort(-scores)
+                scores = scores[indices]
+
+                # retro_transformer.filter_by_attributes()
+                if filters:
+                    bool_mask = np.isin(indices, filtered_indices)
+                    indices = indices[bool_mask]
+                    scores = scores[bool_mask]
+
+                # template_prioritizer.truncate()
+                if max_num_templates:
+                    indices = indices[:max_num_templates]
+                    scores = scores[:max_num_templates]
+
+                if max_cum_prob:
+                    exceeds = np.nonzero(np.cumsum(scores) >= max_cum_prob)[0]
+                    if exceeds.size:
+                        # Include the prediction which exceeds max_cum_prob
+                        max_index = exceeds[0] + 1
+                        scores = scores[:max_index]
+                        indices = indices[:max_index]
+
+                smiles_to_index = {}
+                result = {
+                    "templates": [],
+                    "reactants": [],
+                    "scores": []
+                }
+                for rank, (score, idx) in enumerate(zip(scores, indices), start=1):
+                    template = self.templates[idx]
+                    # IMPORTANT MAGIC from v1. DO NOT TOUCH
+                    # Force reactants and products to be one pseudo-molecule (bookkeeping)
+                    reaction_smarts = template["reaction_smarts"]
+                    reaction_smarts_one = "(" + reaction_smarts.replace(">>", ")>>(") + ")"
+                    rxn = rdchiralReaction(str(reaction_smarts_one))
+                    prod = rdchiralReactants(smi)
+                    try:
+                        # New: set return_mapped to False. Remap after in expand_one
+                        reactants = rdchiralRun(rxn, prod, return_mapped=False)
+                    except:
+                        continue                # unknown error in rdchiral
+
+                    if not reactants:           # empty precursors
+                        continue
+
+                    template = {k: v for k, v in template.items()
+                                if k not in ["references", "rxn"]}
+                    template["template_score"] = score.item()
+                    template["template_rank"] = rank
+
+                    for reactant in reactants:
+                        # here we just return the full template with metadata
+                        # in theory it should also be fetchable from the DB
+                        smiles_list = reactant.split(".")
+                        if template["intra_only"] and len(smiles_list) > 1:
+                            # Disallowed intermolecular reaction
+                            continue
+                        if template["dimer_only"] and (
+                            len(set(smiles_list)) != 1 or len(smiles_list) != 2
+                        ):
+                            # Not a dimer
+                            continue
+                        if smi in smiles_list:
+                            # Skip if no transformation happened
+                            continue
+
+                        joined_smiles = ".".join(sorted(smiles_list))
+                        if joined_smiles in smiles_to_index:
+                            # Precursor was already generated by another template
+                            # -> update metadata. Templates are ordered by score, so
+                            # no need to update template score or rank
+                            res = result["templates"][
+                                smiles_to_index[joined_smiles]
+                            ]
+                            if template["_id"] not in res["tforms"]:
+                                res["tforms"].append(template["_id"])
+                            res["num_examples"] += template["count"]
+                        else:
+                            # New precursor -> generate metadata
+                            template["tforms"] = [template["_id"]]
+                            template["num_examples"] = template["count"]
+                            smiles_to_index[joined_smiles] = len(result["templates"])
+
+                            result["templates"].append(template)
+                            result["reactants"].append(reactant)
+                            result["scores"].append(score.item())
+
+                    del rxn, prod, reactants
+
+                results.append(result)
+
+        return results
+
+    def postprocess(self, data: List[Dict[str, Any]]) -> List[List[Dict[str, Any]]]:
+        return [data]
+
+    def handle(self, data: List, context) -> List[List[Dict[str, Any]]]:
+        self._context = context
+
+        inputs = self.preprocess(data)
+        output = self.inference(inputs)
+        output = self.postprocess(output)
+
+        # print(output)     # turn off (debug) printing to speed up
+
+        return output

checkpoints/askcos_retro_template_relevance/reaxys/aux/mar_files/templ_rel_parser.py

@@ -0,0 +1,72 @@
+def add_model_opts(parser):
+    """Model options"""
+    group = parser.add_argument_group("template_relevance_model")
+    group.add_argument("--seed", help="random seed", type=int, default=0)
+    group.add_argument("--load_from", help="Trained checkpoint to load from",
+                       type=str, default="")
+    group.add_argument("--log_file", help="Log file name",
+                       type=str, default="default")
+    group.add_argument("--model_path", help="Checkpoint folder",
+                       type=str, default="./checkpoints")
+    group.add_argument('--local_rank', help='Local process rank',
+                       type=int, default=-1, metavar='N')
+    group.add_argument("--num_cores", help="number of cpu cores to use",
+                       type=int, default=4)
+    group.add_argument("--min_freq", help="minimum frequency of template in training "
+                                          "data to be retained",
+                       type=int, default=1)
+    group.add_argument("--n_templates", help="number of training templates",
+                       type=int, default=4)
+    group.add_argument("--radius", help="fingerprint radius", type=int, default=2)
+    group.add_argument("--fp_size", help="fingerprint size", type=int, default=2048)
+    group.add_argument("--hidden_sizes",
+                       help="hidden sizes, as a single comma-separated string",
+                       type=str, default="1024")
+    group.add_argument("--hidden_activation", help="hidden activation",
+                       type=str, default="relu")
+    group.add_argument("--skip_connection", help="type of skip connection "
+                                                 "(for backward compatibility)",
+                       type=str, choices=["none", "highway"], default="none")
+    group.add_argument("--gating_activation", help="activation for highway gating",
+                       type=str, default="sigmoid")
+    group.add_argument("--dropout", help="hidden dropout", type=float, default=0.1)
+
+
+def add_train_opts(parser):
+    """Training options"""
+    group = parser.add_argument_group("template_relevance_train")
+    group.add_argument("--backend", help="Backend for DDP", type=str, default="gloo")
+    group.add_argument("--train_batch_size", help="training batch size",
+                       type=int, default=128)
+    group.add_argument("--val_batch_size", help="validation batch size",
+                       type=int, default=256)
+    group.add_argument("--learning_rate", help="learning rate",
+                       type=float, default=1e-3)
+    group.add_argument("--clip_norm", help="Max norm for gradient clipping",
+                       type=float, default=20.0)
+    group.add_argument("--epochs", help="num. of epochs", type=int, default=30)
+    group.add_argument("--early_stop", help="whether to use early stopping",
+                       action="store_true")
+    group.add_argument("--early_stop_patience",
+                       help="num. of epochs w/o improvement before early stop",
+                       type=int, default=2)
+    group.add_argument("--early_stop_min_delta",
+                       help="min. improvement in criteria needed to not early stop",
+                       type=float, default=1e-4)
+    group.add_argument("--lr_scheduler_factor",
+                       help="factor by which to reduce LR (ReduceLROnPlateau)",
+                       type=float, default=0.3)
+    group.add_argument("--lr_scheduler_patience",
+                       help="num. of epochs w/o improvement before "
+                            "reducing LR (ReduceLROnPlateau)",
+                       type=int, default=1)
+    group.add_argument("--lr_cooldown", help="epochs to wait before resuming "
+                                             "normal operation (ReduceLROnPlateau)",
+                       type=int, default=0)
+
+
+def add_predict_opts(parser):
+    """Predicting options"""
+    group = parser.add_argument_group("template_relevance_predict")
+    group.add_argument("--test_batch_size", help="Testing batch size",
+                       type=int, default=256)

checkpoints/askcos_retro_template_relevance/reaxys/aux/mar_files/utils.py

@@ -0,0 +1,207 @@
+import datetime
+import json
+import logging
+import math
+import misc
+import numpy as np
+import os
+import pandas as pd
+import random
+import sys
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from models import TemplRel
+from rdchiral.initialization import rdchiralReaction
+from rdkit import Chem
+from rdkit.Chem import AllChem, DataStructs
+from rdkit.Chem.rdFingerprintGenerator import GetMorganGenerator
+from scipy import sparse
+from torch.nn.init import xavier_uniform_
+from torch.nn.parallel import DistributedDataParallel as DDP
+from typing import Any, Dict, List, Tuple
+
+
+def set_seed(seed: int) -> None:
+    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 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 canonicalize_smiles(smiles: str, remove_atom_number: bool = True) -> str:
+    """Adapted from Molecular Transformer"""
+    smiles = "".join(smiles.split())
+    cano_smiles = ""
+
+    mol = Chem.MolFromSmiles(smiles)
+
+    if mol is not None:
+        if remove_atom_number:
+            [a.ClearProp('molAtomMapNumber') for a in mol.GetAtoms()]
+
+        cano_smiles = Chem.MolToSmiles(mol, isomericSmiles=True, canonical=True)
+        # Sometimes stereochem takes another canonicalization... (just in case)
+        mol = Chem.MolFromSmiles(cano_smiles)
+        if mol is not None:
+            cano_smiles = Chem.MolToSmiles(mol, isomericSmiles=True, canonical=True)
+
+    return cano_smiles
+
+
+def canonicalize_smarts(smarts: str) -> str:
+    templ = Chem.MolFromSmarts(smarts)
+    if templ is None:
+        logging.info(f'Could not parse {smarts}')
+        return smarts
+
+    canon_smarts = Chem.MolToSmarts(templ)
+    if '[[se]]' in canon_smarts:            # strange parse error
+        canon_smarts = smarts
+
+    return canon_smarts
+
+
+def mol_smi_to_count_fp_min_htoo(
+    mol_smi: str, radius: int = 2, fp_size: int = 2048, dtype: str = "int32"
+) -> sparse.csr_matrix:
+    fp_gen = GetMorganGenerator(
+        radius=radius, countSimulation=True, includeChirality=True, fpSize=fp_size
+    )
+    mol = Chem.MolFromSmiles(mol_smi)
+    uint_count_fp = fp_gen.GetCountFingerprint(mol)
+    count_fp = np.empty((1, fp_size), dtype=dtype)
+    DataStructs.ConvertToNumpyArray(uint_count_fp, count_fp)
+
+    return sparse.csr_matrix(count_fp, dtype=dtype)
+
+
+def mol_smi_to_count_fp(
+    mol_smi: str, radius: int = 2, fp_size: int = 2048, dtype: str = "int32"
+) -> sparse.csr_matrix:
+    mol = Chem.MolFromSmiles(mol_smi)
+    fp_bit = AllChem.GetMorganFingerprintAsBitVect(
+        mol,
+        radius=radius,
+        nBits=fp_size,
+        useChirality=True
+    )
+    fp = np.empty((1, fp_size), dtype=dtype)
+    DataStructs.ConvertToNumpyArray(fp_bit, fp)
+
+    return sparse.csr_matrix(fp, dtype=dtype)
+
+
+def get_model(args, device) -> Tuple[nn.Module, Dict[str, Any]]:
+    state = {}
+    if args.load_from:
+        misc.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"]
+        misc.log_args(pretrain_args, message="Logging pretraining args")
+
+        model = TemplRel(pretrain_args)
+        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)
+        misc.log_rank_0("Loaded pretrained model state_dict.")
+
+        # Overwrite for preprocessing during (likely) inference
+        args.fp_size = pretrain_args.fp_size
+        args.radius = pretrain_args.radius
+    else:
+        model = TemplRel(args)
+        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
+        )
+        misc.log_rank_0("DDP setup finished")
+
+    return model, state
+
+
+def save_templates_from_list(templates: List[Dict[str, Any]], template_file: str):
+    with open(template_file, "w") as of:
+        for template in templates:
+            if "rxn" in template:
+                del template["rxn"]
+            of.write(f"{json.dumps(template)}\n")
+
+
+def save_templates_from_dict(templates: Dict[str, Dict[str, Any]], template_file: str):
+    with open(template_file, "w") as of:
+        for canon_templ, metadata in templates.items():
+            assert metadata["reaction_smarts"] == canon_templ
+            if "rxn" in metadata:
+                del metadata["rxn"]
+            of.write(f"{json.dumps(metadata)}\n")
+
+
+def load_templates_as_list(template_file: str
+                           ) -> Tuple[List[Dict[str, Any]], pd.DataFrame]:
+    templates = []
+    template_attributes = []
+
+    with open(template_file, "r") as f:
+        for line in f:
+            template = json.loads(line.strip())
+            del template["references"]
+
+            templates.append(template)
+            template_attributes.append(template.get("attributes", {}))
+    template_attributes = pd.DataFrame(template_attributes)
+
+    return templates, template_attributes
+
+
+def load_templates_as_dict(template_file: str) -> Dict[str, Dict[str, Any]]:
+    templates = {}
+
+    with open(template_file, "r") as f:
+        for line in f:
+            template = json.loads(line.strip())
+            templates[template["reaction_smarts"]] = template
+
+    return templates
+
+
+def get_lr(optimizer) -> float:
+    for param_group in optimizer.param_groups:
+        return param_group["lr"]
+
+
+def param_count(model: nn.Module) -> int:
+    return sum(param.numel() for param in model.parameters() if param.requires_grad)
+
+
+def param_norm(m: nn.Module) -> float:
+    return math.sqrt(sum([p.norm().item() ** 2 for p in m.parameters()]))
+
+
+def grad_norm(m: nn.Module) -> float:
+    return math.sqrt(sum([p.grad.norm().item() ** 2
+                          for p in m.parameters() if p.grad is not None]))

checkpoints/askcos_retro_template_relevance/reaxys/aux/mar_members.json

@@ -0,0 +1,52 @@
+{
+  "members": [
+    {
+      "compress_size": 36834540,
+      "modified": "2023-07-07T04:15:38",
+      "path": "templates.jsonl",
+      "size": 178512888
+    },
+    {
+      "compress_size": 441,
+      "modified": "2023-07-11T20:38:48",
+      "path": "misc.py",
+      "size": 1062
+    },
+    {
+      "compress_size": 2113,
+      "modified": "2023-09-17T00:40:16",
+      "path": "utils.py",
+      "size": 6591
+    },
+    {
+      "compress_size": 1249,
+      "modified": "2023-07-11T20:38:48",
+      "path": "models.py",
+      "size": 4027
+    },
+    {
+      "compress_size": 181512384,
+      "modified": "2023-07-07T04:15:40",
+      "path": "model_latest.pt",
+      "size": 201031079
+    },
+    {
+      "compress_size": 992,
+      "modified": "2023-09-16T23:59:50",
+      "path": "templ_rel_parser.py",
+      "size": 4119
+    },
+    {
+      "compress_size": 2524,
+      "modified": "2023-09-17T00:44:00",
+      "path": "templ_rel_handler.py",
+      "size": 8685
+    },
+    {
+      "compress_size": 140,
+      "modified": "2023-09-17T00:44:10",
+      "path": "MAR-INF/MANIFEST.json",
+      "size": 203
+    }
+  ]
+}

checkpoints/askcos_retro_template_relevance/reaxys/aux/model_args.json

@@ -0,0 +1,24 @@
+{
+  "dropout": 0.1,
+  "fp_size": 2048,
+  "gating_activation": "sigmoid",
+  "hidden_activation": "relu",
+  "hidden_sizes": [
+    300,
+    300,
+    300,
+    300,
+    300
+  ],
+  "load_from": "",
+  "min_freq": 1,
+  "model_ckpt_new": "./tmp/legacy_v2/reaxys.pt",
+  "model_folder_old": "./tmp/legacy_v1/reaxys/1",
+  "n_params": 50256523,
+  "n_templates": 163723,
+  "num_cores": 4,
+  "radius": 2,
+  "skip_connection": "none",
+  "template_file_new": "./tmp/legacy_v2/retro.templates.reaxys.jsonl",
+  "template_file_old": "./tmp/legacy_v1/retro.templates.json.gz"
+}

checkpoints/askcos_retro_template_relevance/reaxys/aux/safetensors_conversion.json

@@ -0,0 +1,12 @@
+{
+  "format": "safetensors",
+  "num_tensors": 12,
+  "path": "model.safetensors",
+  "roundtrip_tensor_equal": true,
+  "runtime_assets": {
+    "model_args": "aux/model_args.json",
+    "templates": "aux/templates.jsonl"
+  },
+  "source_member": "model_latest.pt",
+  "status": "converted"
+}

checkpoints/askcos_retro_template_relevance/reaxys/benchmarks/metadata.json

@@ -0,0 +1,32 @@
+{
+  "benchmark_variant": "askcos_paroutes_compatibility_view",
+  "built_at": "1970-01-01T00:00:00+00:00",
+  "checkpoint_id": "reaxys",
+  "dataset_id": "askcos_retro_template_relevance_reaxys_paroutes_reference_route_test",
+  "dataset_ref": "paroutes2_reference_route_reactions",
+  "native_input_format": "tab_delimited_reactants_reagents_product_rows",
+  "native_sources": [
+    {
+      "notes": [
+        "Public PaRoutes selected_reactions.csv source table used to reconstruct the one-step reference-route reaction subset."
+      ],
+      "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"
+    },
+    {
+      "notes": [
+        "Public PaRoutes hash list identifying the reference-route reactions used here as a redistribution-safe ASKCOS compatibility benchmark."
+      ],
+      "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"
+    }
+  ],
+  "notes": [
+    "ASKCOS does not redistribute the native train/validation/test split for this TorchServe archive in datasets/modelos_ASKCOS.",
+    "This bundled benchmark is therefore a public PaRoutes one-step retrosynthesis compatibility view, not a claim about the model's original validation split."
+  ],
+  "num_examples": 56657,
+  "split": "test"
+}

checkpoints/askcos_retro_template_relevance/reaxys/manifest.json

@@ -0,0 +1,139 @@
+{
+  "auxiliary_files": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl",
+    "benchmarks/default_test.jsonl",
+    "benchmarks/metadata.json",
+    "benchmarks/native/ref_routes_reaction_hashes.txt",
+    "benchmarks/native/selected_reactions.csv"
+  ],
+  "benchmark_datasets": [
+    {
+      "benchmark_variant": "askcos_paroutes_compatibility_view",
+      "dataset_id": "askcos_retro_template_relevance_reaxys_paroutes_reference_route_test",
+      "dataset_ref": "paroutes2_reference_route_reactions",
+      "default": true,
+      "format": "jsonl",
+      "metadata_path": "benchmarks/metadata.json",
+      "native_input_format": "tab_delimited_reactants_reagents_product_rows",
+      "native_source_paths": [
+        "benchmarks/native/selected_reactions.csv",
+        "benchmarks/native/ref_routes_reaction_hashes.txt"
+      ],
+      "notes": [
+        "ASKCOS does not redistribute the native train/validation/test split for this TorchServe archive in datasets/modelos_ASKCOS.",
+        "This bundled benchmark is therefore a public PaRoutes one-step retrosynthesis compatibility view, not a claim about the model's original validation split."
+      ],
+      "num_examples": 56657,
+      "path": "benchmarks/default_test.jsonl",
+      "split": "test"
+    }
+  ],
+  "checkpoint_id": "reaxys",
+  "contained_artifact_bindings": [
+    {
+      "canonical_split_family": "askcos_reaxys_split_unspecified",
+      "dataset_ref": "askcos_reaxys_release",
+      "path": "modelos_ASKCOS/mars/reaxys.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": 12,
+      "path": "model.safetensors",
+      "roundtrip_tensor_equal": true,
+      "runtime_assets": {
+        "model_args": "aux/model_args.json",
+        "templates": "aux/templates.jsonl"
+      },
+      "source_member": "model_latest.pt",
+      "status": "converted"
+    },
+    "source_format": "torchserve_mar_embedded_checkpoint",
+    "status": "converted",
+    "tool_version": "initial"
+  },
+  "display_name": "reaxys",
+  "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"
+  },
+  "license": "cc-by-nc-4.0",
+  "model_id": "askcos_retro_template_relevance",
+  "model_role": "backward",
+  "normalized_checkpoint_id": "reaxys",
+  "package_layout": {
+    "aux_dir": "aux",
+    "benchmarks_dir": "benchmarks",
+    "weights_path": "model.safetensors"
+  },
+  "source_registry_refs": [
+    {
+      "checkpoint_id": "reaxys",
+      "model_id": "askcos_retro_template_relevance"
+    }
+  ],
+  "split_provenance": [
+    {
+      "canonical_split_family": "askcos_reaxys_split_unspecified",
+      "dataset_ref": "askcos_reaxys_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_reaxys_split_unspecified",
+      "dataset_ref": "askcos_reaxys_release",
+      "path": "modelos_ASKCOS/mars/reaxys.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "task_direction": "retrosynthesis",
+  "training_dataset_refs": [
+    "askcos_reaxys_release"
+  ],
+  "training_stage_bindings": [
+    {
+      "canonical_split_family": "askcos_reaxys_split_unspecified",
+      "dataset_ref": "askcos_reaxys_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_reaxys_split_unspecified",
+      "dataset_ref": "askcos_reaxys_release",
+      "path": "modelos_ASKCOS/mars/reaxys.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "weights": {
+    "dtype_summary": "float tensors preserved from upstream checkpoint",
+    "framework": "safetensors",
+    "path": "model.safetensors",
+    "tensor_namespace": "askcos_template_relevance"
+  },
+  "wrapper_config": "wrapper_config.json",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/reaxys/provenance.json

@@ -0,0 +1,89 @@
+{
+  "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/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl"
+  ],
+  "inner_members": [
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "member": "templates.jsonl",
+      "role": "template_library"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "member": "misc.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "member": "utils.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "member": "models.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "member": "model_latest.pt",
+      "role": "weights_source"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "member": "templ_rel_parser.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "member": "templ_rel_handler.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "member": "MAR-INF/MANIFEST.json",
+      "role": "torchserve_manifest"
+    }
+  ],
+  "normalized_checkpoint_id": "reaxys",
+  "source_artifacts": [
+    {
+      "absolute_path": "/mnt/HDD/syntheseus-bundle-builder/datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/mars/reaxys.mar",
+      "role": "source_artifact",
+      "sha256": "fb05bb216df2c6483bccc738dbc0e5b17a9d6ce3c4f07f4ad8dcda7a0c7ac526",
+      "size": 218355241
+    },
+    {
+      "absolute_path": "/mnt/HDD/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": "/mnt/HDD/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_template_relevance/reaxys/wrapper_config.json

@@ -0,0 +1,37 @@
+{
+  "architecture_class": "NeuralSym-style template relevance FFN",
+  "device_supported": [
+    "cpu",
+    "cuda"
+  ],
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "license": "cc-by-nc-4.0",
+  "loader": {
+    "kind": "askcos_template_relevance_safetensors",
+    "model_args": "aux/model_args.json",
+    "model_version": "1.0",
+    "served_model_name": "reaxys",
+    "source_handler": "templ_rel_handler.py",
+    "state_dict_format": "safetensors",
+    "templates": "aux/templates.jsonl"
+  },
+  "package_layout": {
+    "aux_dir": "aux",
+    "weights_path": "model.safetensors"
+  },
+  "runtime_file_map": {
+    "aux/model_args.json": "aux/model_args.json",
+    "aux/templates.jsonl": "aux/templates.jsonl",
+    "model.safetensors": "model.safetensors"
+  },
+  "task_direction": "retrosynthesis",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/reaxys_biocatalysis/SHA256SUMS

@@ -0,0 +1,18 @@
+a57d7f443fc67f3d179de1979b1c6c7480a368fb13ee45d9f434e35ecf49154e  aux/MAR-INF/MANIFEST.json
+f5bef6f645347b15a1bbff2e56117d1a58f56234bdd24d89e9a18bd7a0d193d5  aux/mar_files/misc.py
+8ee17cac57f65d954a599f18bbcf9df069a1acb0be86064a21188d4f5c2171f5  aux/mar_files/models.py
+b5d99468d88374391e7ce7a1766ee287b8fbb9f1dbac70743606d43dee4f9f59  aux/mar_files/templ_rel_handler.py
+9a0d07ded45cd94abeeed5e8c1f30a1e590080b10b4bbc8314aa5e4cbc622d83  aux/mar_files/templ_rel_parser.py
+67bee61a87662e2224bb85725bdf8de048ff4ebcc934fc8ed1cdfd61186e4a4b  aux/mar_files/utils.py
+f6deb7cdcc1d08f99d823a490667d85333714f77426718e705d2b2e26fae7669  aux/mar_members.json
+09beae83ec8d0eff16449792a0aa23fcf263997475ab0ceebb78ea638f6f799e  aux/model_args.json
+bc047b7afb7a1a3dbaf70225560fd396eee228f106ff12f615de80dea999f8b7  aux/safetensors_conversion.json
+01525f0f1a35c06ba74e4120a2ca3f7487c218ebb1ee88b007166865dc54684b  aux/templates.jsonl
+a10255a6abd89a35d2ea48a842839f403b4b1586805c3010c0d076e0ae23754d  benchmarks/default_test.jsonl
+af366ff36fbc686bacc48c5e3bd341d47fe74f69fc39c721eed7eb88593b2252  benchmarks/metadata.json
+87d7e0013f97da27e4fd878b0598466ac07202fe131ac0f7dbdd2b423482751f  benchmarks/native/ref_routes_reaction_hashes.txt
+872533b44788754af3aa19918a04c2a508d30249d2c93eb480078cb638ad3389  benchmarks/native/selected_reactions.csv
+73ab2726a390d128459991eb538690957749562743d9bf1c974abd8939c4cee9  manifest.json
+f27212055fd62b3c3edfa71f6d53a6ae7c2dc27212ac45dbe68b278d714c7ae8  model.safetensors
+46f01b02bf2639b0c5b7c18637eb88c0a8afac23ea036665078fe43d02eacfd4  provenance.json
+bb782bdc4f876a606d6933e45adcb76414a0e2ad847e3fc542a1f61d00d59dcd  wrapper_config.json

checkpoints/askcos_retro_template_relevance/reaxys_biocatalysis/manifest.json

@@ -0,0 +1,139 @@
+{
+  "auxiliary_files": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl",
+    "benchmarks/default_test.jsonl",
+    "benchmarks/metadata.json",
+    "benchmarks/native/ref_routes_reaction_hashes.txt",
+    "benchmarks/native/selected_reactions.csv"
+  ],
+  "benchmark_datasets": [
+    {
+      "benchmark_variant": "askcos_paroutes_compatibility_view",
+      "dataset_id": "askcos_retro_template_relevance_reaxys_biocatalysis_paroutes_reference_route_test",
+      "dataset_ref": "paroutes2_reference_route_reactions",
+      "default": true,
+      "format": "jsonl",
+      "metadata_path": "benchmarks/metadata.json",
+      "native_input_format": "tab_delimited_reactants_reagents_product_rows",
+      "native_source_paths": [
+        "benchmarks/native/selected_reactions.csv",
+        "benchmarks/native/ref_routes_reaction_hashes.txt"
+      ],
+      "notes": [
+        "ASKCOS does not redistribute the native train/validation/test split for this TorchServe archive in datasets/modelos_ASKCOS.",
+        "This bundled benchmark is therefore a public PaRoutes one-step retrosynthesis compatibility view, not a claim about the model's original validation split."
+      ],
+      "num_examples": 56657,
+      "path": "benchmarks/default_test.jsonl",
+      "split": "test"
+    }
+  ],
+  "checkpoint_id": "reaxys_biocatalysis",
+  "contained_artifact_bindings": [
+    {
+      "canonical_split_family": "askcos_reaxys_biocatalysis_split_unspecified",
+      "dataset_ref": "askcos_reaxys_biocatalysis_release",
+      "path": "modelos_ASKCOS/mars/reaxys_biocatalysis.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": 4,
+      "path": "model.safetensors",
+      "roundtrip_tensor_equal": true,
+      "runtime_assets": {
+        "model_args": "aux/model_args.json",
+        "templates": "aux/templates.jsonl"
+      },
+      "source_member": "model_latest.pt",
+      "status": "converted"
+    },
+    "source_format": "torchserve_mar_embedded_checkpoint",
+    "status": "converted",
+    "tool_version": "initial"
+  },
+  "display_name": "reaxys_biocatalysis",
+  "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"
+  },
+  "license": "cc-by-nc-4.0",
+  "model_id": "askcos_retro_template_relevance",
+  "model_role": "backward",
+  "normalized_checkpoint_id": "reaxys_biocatalysis",
+  "package_layout": {
+    "aux_dir": "aux",
+    "benchmarks_dir": "benchmarks",
+    "weights_path": "model.safetensors"
+  },
+  "source_registry_refs": [
+    {
+      "checkpoint_id": "reaxys_biocatalysis",
+      "model_id": "askcos_retro_template_relevance"
+    }
+  ],
+  "split_provenance": [
+    {
+      "canonical_split_family": "askcos_reaxys_biocatalysis_split_unspecified",
+      "dataset_ref": "askcos_reaxys_biocatalysis_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_reaxys_biocatalysis_split_unspecified",
+      "dataset_ref": "askcos_reaxys_biocatalysis_release",
+      "path": "modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "task_direction": "retrosynthesis",
+  "training_dataset_refs": [
+    "askcos_reaxys_biocatalysis_release"
+  ],
+  "training_stage_bindings": [
+    {
+      "canonical_split_family": "askcos_reaxys_biocatalysis_split_unspecified",
+      "dataset_ref": "askcos_reaxys_biocatalysis_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_reaxys_biocatalysis_split_unspecified",
+      "dataset_ref": "askcos_reaxys_biocatalysis_release",
+      "path": "modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "weights": {
+    "dtype_summary": "float tensors preserved from upstream checkpoint",
+    "framework": "safetensors",
+    "path": "model.safetensors",
+    "tensor_namespace": "askcos_template_relevance"
+  },
+  "wrapper_config": "wrapper_config.json",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/reaxys_biocatalysis/provenance.json

@@ -0,0 +1,89 @@
+{
+  "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/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl"
+  ],
+  "inner_members": [
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "member": "templates.jsonl",
+      "role": "template_library"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "member": "misc.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "member": "utils.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "member": "models.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "member": "model_latest.pt",
+      "role": "weights_source"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "member": "templ_rel_parser.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "member": "templ_rel_handler.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "member": "MAR-INF/MANIFEST.json",
+      "role": "torchserve_manifest"
+    }
+  ],
+  "normalized_checkpoint_id": "reaxys_biocatalysis",
+  "source_artifacts": [
+    {
+      "absolute_path": "/mnt/HDD/syntheseus-bundle-builder/datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/mars/reaxys_biocatalysis.mar",
+      "role": "source_artifact",
+      "sha256": "dec101adf3eef9de7bc173278f4e3aefe4c54fd9e045398fb80985145e7d994c",
+      "size": 165468559
+    },
+    {
+      "absolute_path": "/mnt/HDD/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": "/mnt/HDD/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_template_relevance/reaxys_biocatalysis/wrapper_config.json

@@ -0,0 +1,37 @@
+{
+  "architecture_class": "NeuralSym-style template relevance FFN",
+  "device_supported": [
+    "cpu",
+    "cuda"
+  ],
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "license": "cc-by-nc-4.0",
+  "loader": {
+    "kind": "askcos_template_relevance_safetensors",
+    "model_args": "aux/model_args.json",
+    "model_version": "1.0",
+    "served_model_name": "reaxys_biocatalysis",
+    "source_handler": "templ_rel_handler.py",
+    "state_dict_format": "safetensors",
+    "templates": "aux/templates.jsonl"
+  },
+  "package_layout": {
+    "aux_dir": "aux",
+    "weights_path": "model.safetensors"
+  },
+  "runtime_file_map": {
+    "aux/model_args.json": "aux/model_args.json",
+    "aux/templates.jsonl": "aux/templates.jsonl",
+    "model.safetensors": "model.safetensors"
+  },
+  "task_direction": "retrosynthesis",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/uspto_higher_level/SHA256SUMS

@@ -0,0 +1,18 @@
+b7b2ca228a157b9b4df6e70c971e3f7336860544f2ff23c7e40556e86966cd2e  aux/MAR-INF/MANIFEST.json
+f5bef6f645347b15a1bbff2e56117d1a58f56234bdd24d89e9a18bd7a0d193d5  aux/mar_files/misc.py
+8ee17cac57f65d954a599f18bbcf9df069a1acb0be86064a21188d4f5c2171f5  aux/mar_files/models.py
+b5d99468d88374391e7ce7a1766ee287b8fbb9f1dbac70743606d43dee4f9f59  aux/mar_files/templ_rel_handler.py
+52cf84f9aa1f02337d3d5bfad049ce09fd150111b5917aa7d896afe223dee883  aux/mar_files/templ_rel_parser.py
+7033f7390bc992b54a060ccf992d8da538fed53d7f30fc6a6d6165af73566ad1  aux/mar_files/utils.py
+6256064b2b61eab625a625793face8fa47b3226a5e29959a0733ad151c2926cd  aux/mar_members.json
+67227a4e1d20c16fde3841a279deff3b7f5f2fcfcb0263252075ffa6a84b2ef7  aux/model_args.json
+bc047b7afb7a1a3dbaf70225560fd396eee228f106ff12f615de80dea999f8b7  aux/safetensors_conversion.json
+3b8ca4a6d7b5157f61c4dc0d922dae64c589ef2555e472b5f1c2669b46e9306b  aux/templates.jsonl
+a10255a6abd89a35d2ea48a842839f403b4b1586805c3010c0d076e0ae23754d  benchmarks/default_test.jsonl
+f4395261a25edfd67ae73c77f77aaa42a614c99114959973d98332fc51fc22db  benchmarks/metadata.json
+87d7e0013f97da27e4fd878b0598466ac07202fe131ac0f7dbdd2b423482751f  benchmarks/native/ref_routes_reaction_hashes.txt
+872533b44788754af3aa19918a04c2a508d30249d2c93eb480078cb638ad3389  benchmarks/native/selected_reactions.csv
+1a7cc2e955245c897cc240d3cca74bd45da2242cc52c3897df57e9b7091292cf  manifest.json
+dcefcc766f005ec0a1b3cf06941069b29b415b09ea23fd614c4a96485fd489c5  model.safetensors
+2c245c1023c2965739b73eff6fcc1b401081ea0f6c2691595b58ad6f622e9385  provenance.json
+8e0f10e122856e7fa87c182a0e1e167cf9f07e43428ecebc01c9d85f9e173219  wrapper_config.json

checkpoints/askcos_retro_template_relevance/uspto_higher_level/aux/MAR-INF/MANIFEST.json

@@ -0,0 +1,10 @@
+{
+  "archiverVersion": "0.3.1",
+  "createdOn": "17/04/2026 19:55:38",
+  "model": {
+    "handler": "templ_rel_handler.py",
+    "modelName": "uspto_higher_level",
+    "modelVersion": "1.0"
+  },
+  "runtime": "python"
+}

checkpoints/askcos_retro_template_relevance/uspto_higher_level/aux/mar_files/misc.py

@@ -0,0 +1,45 @@
+import logging
+import os
+import sys
+import torch
+
+
+class BlockPrint:
+    """Context manager to suppress printing from subprocesses"""
+    def __enter__(self):
+        self._original_stdout = sys.stdout
+        sys.stdout = open(os.devnull, 'w')
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        sys.stdout.close()
+        sys.stdout = self._original_stdout
+
+
+def log_args(args, message: str):
+    log_rank_0(message)
+    for k, v in vars(args).items():
+        log_rank_0(f"**** {k} = *{v}*")
+
+
+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 setup_logger(log_file):
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+
+    fh = logging.FileHandler(log_file)
+    sh = logging.StreamHandler(sys.stdout)
+    fh.setLevel(logging.INFO)
+    sh.setLevel(logging.INFO)
+    logger.addHandler(fh)
+    logger.addHandler(sh)
+
+    return logger

checkpoints/askcos_retro_template_relevance/uspto_higher_level/aux/mar_files/models.py

@@ -0,0 +1,119 @@
+import torch
+import torch.nn as nn
+from typing import Tuple
+
+
+def get_activation(name: str) -> nn.Module:
+    _activations = {
+        "relu": nn.ReLU(),
+        "elu": nn.ELU(),
+        "gelu": nn.GELU(),
+        "leakyrelu": nn.LeakyReLU(),
+        "sigmoid": nn.Sigmoid(),
+        "tanh": nn.Tanh()
+    }
+
+    return _activations[name]
+
+
+class Dense(nn.Module):
+    def __init__(self, in_features: int, out_features: int,
+                 hidden_act: nn.Module):
+        super().__init__()
+        self.linear = nn.Linear(in_features, out_features, bias=True)
+        self.hidden_act = hidden_act
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.hidden_act(self.linear(x))
+
+
+class Highway(nn.Module):
+    def __init__(self, in_features: int, out_features: int,
+                 hidden_act: nn.Module, gating_act: nn.Module):
+        super().__init__()
+        self.dense = nn.Linear(in_features, out_features, bias=True)
+        self.gate = nn.Linear(in_features, out_features, bias=True)
+        self.hidden_act = hidden_act
+        self.gating_act = gating_act
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        transform = self.hidden_act(self.dense(x))
+        transform_gate = self.gating_act(self.gate(x))
+        carry_gate = 1 - transform_gate
+        output = transform * transform_gate + x * carry_gate
+
+        return output
+
+
+class TemplRel(nn.Module):
+    def __init__(self, args):
+        super().__init__()
+
+        if isinstance(args.hidden_sizes, str):
+            args.hidden_sizes = [int(size) for size in args.hidden_sizes.split(",")]
+
+        self.args = args
+        self.layers = self._build_layers(args)
+        self.output_layer = nn.Linear(
+            args.hidden_sizes[-1], args.n_templates, bias=True)
+
+        # we will do all the dropout here in TemplRel, for backward compatibility
+        self.dropout = nn.Dropout(args.dropout)
+        self.criterion = nn.CrossEntropyLoss(ignore_index=-1, reduction="mean")
+
+    @staticmethod
+    def _build_layers(args) -> nn.ModuleList:
+        hidden_act = get_activation(args.hidden_activation)
+        # input projection layer; no skip connection here
+        layers = nn.ModuleList([
+            Dense(args.fp_size, args.hidden_sizes[0], hidden_act=hidden_act)
+        ])
+
+        for layer_i in range(len(args.hidden_sizes) - 1):
+            in_features = args.hidden_sizes[layer_i]
+            out_features = args.hidden_sizes[layer_i + 1]
+
+            if args.skip_connection == "none":
+                layer = Dense(in_features, out_features, hidden_act=hidden_act)
+            elif args.skip_connection == "highway":
+                layer = Highway(
+                    in_features,
+                    out_features,
+                    hidden_act=hidden_act,
+                    gating_act=get_activation(args.gating_activation)
+                )
+            else:
+                raise ValueError(
+                    f"Unsupported skip_connection: {args.skip_connection}"
+                )
+
+            layers.append(layer)
+
+        return layers
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        for layer in self.layers:
+            x = layer(x)
+            x = self.dropout(x)
+
+        logits = self.output_layer(x)           # returning *unnormalized* logits
+
+        return logits
+
+    def get_loss(self, logits: torch.Tensor, target: torch.Tensor
+                 ) -> Tuple[torch.Tensor, torch.Tensor]:
+        loss = self.criterion(input=logits, target=target)
+
+        predictions = torch.argmax(logits, dim=1)
+        accs = (predictions == target).float()
+        acc = accs.mean()
+
+        # Data points with label -1 (no/failed templates) should really be treated as
+        # if they are predicted wrong. Therefore, we turned off the masking. This may
+        # noticeably decrease the computed accuracy, but would reflect the reality.
+
+        # mask = (target != -1).long()
+        # accs = accs * mask
+        # acc = accs.sum() / mask.sum()
+
+        return loss, acc

checkpoints/askcos_retro_template_relevance/uspto_higher_level/aux/mar_files/templ_rel_handler.py

@@ -0,0 +1,201 @@
+import argparse
+import glob
+import numpy as np
+import os
+import templ_rel_parser
+import torch
+import torch.nn.functional as F
+from utils import canonicalize_smiles
+from rdchiral.initialization import rdchiralReactants, rdchiralReaction
+from rdchiral.main import rdchiralRun
+from typing import Any, Dict, List, Tuple
+from utils import get_model, load_templates_as_list, mol_smi_to_count_fp
+
+
+class TemplRelHandler:
+    """TemplRel Handler for use with torchserve"""
+
+    def __init__(self):
+        self._context = None
+        self.manifest = None
+        self.initialized = False
+
+        self.args = None
+        self.templates = None
+        self.template_attributes = None
+        self.model = None
+        self.indices = None
+        self.device = None
+
+    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")
+
+        serve_parser = argparse.ArgumentParser("serve")
+        templ_rel_parser.add_predict_opts(serve_parser)
+        self.args, _ = serve_parser.parse_known_args()
+
+        template_file = os.path.join(model_dir, "templates.jsonl")
+        print(f"Loading templates and attributes from {template_file}")
+        self.templates, self.template_attributes = \
+            load_templates_as_list(template_file=template_file)
+        print(f'Total number of templates: {len(self.templates)}')
+
+        checkpoint_file = os.path.join(model_dir, "model_latest.pt")
+        print(f"Building model and loading from {checkpoint_file}")
+
+        self.args.load_from = checkpoint_file
+        self.args.local_rank = -1
+        # Note: the model will be built using pretraining args
+        self.model, _ = get_model(self.args, device=self.device)
+        self.model.eval()
+
+        self.initialized = True
+
+    def preprocess(self, data: List[dict]
+                   ) -> Tuple[List[str], int, float, List[Dict[str, Any]]]:
+        print(f"input: {data}")
+        canonical_smiles = [canonicalize_smiles(smi)
+                            for smi in data[0]["body"]["smiles"]]
+        max_num_templates = data[0]["body"].get("max_num_templates", 1000)
+        max_cum_prob = data[0]["body"].get("max_cum_prob", 0.999)
+        attribute_filter = data[0]["body"].get("attribute_filter", [])
+
+        return canonical_smiles, max_num_templates, max_cum_prob, attribute_filter
+
+    def inference(self, inputs: Tuple[List[str], int, float, List[Dict[str, Any]]]
+                  ) -> List[Dict[str, Any]]:
+        canonical_smiles, max_num_templates, max_cum_prob, attribute_filter = inputs
+        filters = [x for x in attribute_filter
+                   if x.get("name") in self.template_attributes]
+
+        if filters:
+            filter_query = " and ".join(
+                [f"({q['name']} {q['logic']} {q['value']})" for q in filters]
+            )
+            filtered_indices = self.template_attributes.query(filter_query).index.values
+
+        results = []
+
+        # maybe not the most efficient way, but should have been faster than v1 already
+        with torch.no_grad():
+            for smi in canonical_smiles:
+                prod_fp = mol_smi_to_count_fp(smi, self.args.radius, self.args.fp_size)
+                final_fp = torch.as_tensor(prod_fp.toarray()).float().to(self.device)
+
+                # template_prioritizer.predict()
+                logits = self.model(final_fp)
+                scores = F.softmax(logits, dim=1)
+                scores = scores.squeeze(dim=0).cpu().numpy()
+                indices = np.argsort(-scores)
+                scores = scores[indices]
+
+                # retro_transformer.filter_by_attributes()
+                if filters:
+                    bool_mask = np.isin(indices, filtered_indices)
+                    indices = indices[bool_mask]
+                    scores = scores[bool_mask]
+
+                # template_prioritizer.truncate()
+                if max_num_templates:
+                    indices = indices[:max_num_templates]
+                    scores = scores[:max_num_templates]
+
+                if max_cum_prob:
+                    exceeds = np.nonzero(np.cumsum(scores) >= max_cum_prob)[0]
+                    if exceeds.size:
+                        # Include the prediction which exceeds max_cum_prob
+                        max_index = exceeds[0] + 1
+                        scores = scores[:max_index]
+                        indices = indices[:max_index]
+
+                smiles_to_index = {}
+                result = {
+                    "templates": [],
+                    "reactants": [],
+                    "scores": []
+                }
+                for rank, (score, idx) in enumerate(zip(scores, indices), start=1):
+                    template = self.templates[idx]
+                    # IMPORTANT MAGIC from v1. DO NOT TOUCH
+                    # Force reactants and products to be one pseudo-molecule (bookkeeping)
+                    reaction_smarts = template["reaction_smarts"]
+                    reaction_smarts_one = "(" + reaction_smarts.replace(">>", ")>>(") + ")"
+                    rxn = rdchiralReaction(str(reaction_smarts_one))
+                    prod = rdchiralReactants(smi)
+                    try:
+                        # New: set return_mapped to False. Remap after in expand_one
+                        reactants = rdchiralRun(rxn, prod, return_mapped=False)
+                    except:
+                        continue                # unknown error in rdchiral
+
+                    if not reactants:           # empty precursors
+                        continue
+
+                    template = {k: v for k, v in template.items()
+                                if k not in ["references", "rxn"]}
+                    template["template_score"] = score.item()
+                    template["template_rank"] = rank
+
+                    for reactant in reactants:
+                        # here we just return the full template with metadata
+                        # in theory it should also be fetchable from the DB
+                        smiles_list = reactant.split(".")
+                        if template["intra_only"] and len(smiles_list) > 1:
+                            # Disallowed intermolecular reaction
+                            continue
+                        if template["dimer_only"] and (
+                            len(set(smiles_list)) != 1 or len(smiles_list) != 2
+                        ):
+                            # Not a dimer
+                            continue
+                        if smi in smiles_list:
+                            # Skip if no transformation happened
+                            continue
+
+                        joined_smiles = ".".join(sorted(smiles_list))
+                        if joined_smiles in smiles_to_index:
+                            # Precursor was already generated by another template
+                            # -> update metadata. Templates are ordered by score, so
+                            # no need to update template score or rank
+                            res = result["templates"][
+                                smiles_to_index[joined_smiles]
+                            ]
+                            if template["_id"] not in res["tforms"]:
+                                res["tforms"].append(template["_id"])
+                            res["num_examples"] += template["count"]
+                        else:
+                            # New precursor -> generate metadata
+                            template["tforms"] = [template["_id"]]
+                            template["num_examples"] = template["count"]
+                            smiles_to_index[joined_smiles] = len(result["templates"])
+
+                            result["templates"].append(template)
+                            result["reactants"].append(reactant)
+                            result["scores"].append(score.item())
+
+                    del rxn, prod, reactants
+
+                results.append(result)
+
+        return results
+
+    def postprocess(self, data: List[Dict[str, Any]]) -> List[List[Dict[str, Any]]]:
+        return [data]
+
+    def handle(self, data: List, context) -> List[List[Dict[str, Any]]]:
+        self._context = context
+
+        inputs = self.preprocess(data)
+        output = self.inference(inputs)
+        output = self.postprocess(output)
+
+        # print(output)     # turn off (debug) printing to speed up
+
+        return output

checkpoints/askcos_retro_template_relevance/uspto_higher_level/aux/mar_files/templ_rel_parser.py

@@ -0,0 +1,94 @@
+def add_model_opts(parser):
+    """Model options"""
+    group = parser.add_argument_group("template_relevance")
+    group.add_argument("--data_name", help="Data name", type=str, default="Template Relevance")
+    group.add_argument("--model_name", help="Model name", type=str, default="Template Relevance")
+    group.add_argument("--seed", help="random seed", type=int, default=0)
+    group.add_argument("--load_from", help="Trained checkpoint to load from",
+                       type=str, default="")
+    group.add_argument("--log_file", help="Log file name",
+                       type=str, default="default")
+    group.add_argument("--model_path", help="Checkpoint folder",
+                       type=str, default="./checkpoints")
+    group.add_argument('--local_rank', help='Local process rank',
+                       type=int, default=-1, metavar='N')
+    group.add_argument("--num_cores", help="number of cpu cores to use",
+                       type=int, default=4)
+    group.add_argument("--min_freq", help="minimum frequency of template in training "
+                                          "data to be retained",
+                       type=int, default=1)
+    group.add_argument("--n_templates", help="number of training templates",
+                       type=int, default=4)
+    group.add_argument("--radius", help="fingerprint radius", type=int, default=2)
+    group.add_argument("--fp_size", help="fingerprint size", type=int, default=2048)
+    group.add_argument("--hidden_sizes",
+                       help="hidden sizes, as a single comma-separated string",
+                       type=str, default="1024")
+    group.add_argument("--hidden_activation", help="hidden activation",
+                       type=str, default="relu")
+    group.add_argument("--skip_connection", help="type of skip connection "
+                                                 "(for backward compatibility)",
+                       type=str, choices=["none", "highway"], default="none")
+    group.add_argument("--gating_activation", help="activation for highway gating",
+                       type=str, default="sigmoid")
+    group.add_argument("--dropout", help="hidden dropout", type=float, default=0.1)
+
+    group = parser.add_argument_group("Paths")
+    group.add_argument("--processed_data_path", help="Path for saving preprocessed outputs",
+                       type=str, default="")
+    group.add_argument("--test_output_path", help="Path for saving test outputs", type=str, default="")
+
+
+def add_preprocess_opts(parser):
+    group = parser.add_argument_group("Preprocessing options")
+    # data paths
+    group.add_argument("--all_reaction_file", help="All reaction file", type=str, default="")
+    group.add_argument("--split_ratio", help="Split ratio of dataset", type=str, default="8:1:1")
+
+    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="")
+    group.add_argument("--partition", help="Data partition", type=int, default=1)
+    group.add_argument("--is_data_presplit", help="Whether the data is presplit", action="store_true")
+    group.add_argument("--stage", help="(Hardcoded) preprocessing stage", type=str)
+
+
+def add_train_opts(parser):
+    """Training options"""
+    group = parser.add_argument_group("template_relevance_train")
+    group.add_argument("--backend", help="Backend for DDP", type=str, default="gloo")
+    group.add_argument("--train_batch_size", help="training batch size",
+                       type=int, default=128)
+    group.add_argument("--val_batch_size", help="validation batch size",
+                       type=int, default=256)
+    group.add_argument("--learning_rate", help="learning rate",
+                       type=float, default=1e-3)
+    group.add_argument("--clip_norm", help="Max norm for gradient clipping",
+                       type=float, default=20.0)
+    group.add_argument("--epochs", help="num. of epochs", type=int, default=30)
+    group.add_argument("--early_stop", help="whether to use early stopping",
+                       action="store_true")
+    group.add_argument("--early_stop_patience",
+                       help="num. of epochs w/o improvement before early stop",
+                       type=int, default=2)
+    group.add_argument("--early_stop_min_delta",
+                       help="min. improvement in criteria needed to not early stop",
+                       type=float, default=1e-4)
+    group.add_argument("--lr_scheduler_factor",
+                       help="factor by which to reduce LR (ReduceLROnPlateau)",
+                       type=float, default=0.3)
+    group.add_argument("--lr_scheduler_patience",
+                       help="num. of epochs w/o improvement before "
+                            "reducing LR (ReduceLROnPlateau)",
+                       type=int, default=1)
+    group.add_argument("--lr_cooldown", help="epochs to wait before resuming "
+                                             "normal operation (ReduceLROnPlateau)",
+                       type=int, default=0)
+
+
+def add_predict_opts(parser):
+    """Predicting options"""
+    group = parser.add_argument_group("template_relevance_predict")
+    group.add_argument("--test_batch_size", help="Testing batch size",
+                       type=int, default=256)
+    group.add_argument("--topk", help="Topk", type=int, default=50)

checkpoints/askcos_retro_template_relevance/uspto_higher_level/aux/mar_files/utils.py

@@ -0,0 +1,250 @@
+import datetime
+import gzip
+import json
+import logging
+import math
+import misc
+import numpy as np
+import os
+import pandas as pd
+import random
+import sys
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from models import TemplRel
+from rdkit import Chem
+from rdkit.Chem import AllChem, DataStructs
+from rdkit.Chem.rdFingerprintGenerator import GetMorganGenerator
+from scipy import sparse
+from torch.nn.init import xavier_uniform_
+from torch.nn.parallel import DistributedDataParallel as DDP
+from typing import Any, Dict, List, Tuple
+
+
+def set_seed(seed: int) -> None:
+    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 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 canonicalize_smiles(smiles: str, remove_atom_number: bool = True) -> str:
+    """Adapted from Molecular Transformer"""
+    smiles = "".join(smiles.split())
+    cano_smiles = ""
+
+    mol = Chem.MolFromSmiles(smiles)
+
+    if mol is not None:
+        if remove_atom_number:
+            [a.ClearProp('molAtomMapNumber') for a in mol.GetAtoms()]
+
+        cano_smiles = Chem.MolToSmiles(mol, isomericSmiles=True, canonical=True)
+        # Sometimes stereochem takes another canonicalization... (just in case)
+        mol = Chem.MolFromSmiles(cano_smiles)
+        if mol is not None:
+            cano_smiles = Chem.MolToSmiles(mol, isomericSmiles=True, canonical=True)
+
+    return cano_smiles
+
+
+def canonicalize_smarts(smarts: str) -> str:
+    templ = Chem.MolFromSmarts(smarts)
+    if templ is None:
+        logging.info(f'Could not parse {smarts}')
+        return smarts
+
+    canon_smarts = Chem.MolToSmarts(templ)
+    if '[[se]]' in canon_smarts:            # strange parse error
+        canon_smarts = smarts
+
+    return canon_smarts
+
+
+def mol_smi_to_count_fp_min_htoo(
+    mol_smi: str, radius: int = 2, fp_size: int = 2048, dtype: str = "int32"
+) -> sparse.csr_matrix:
+    fp_gen = GetMorganGenerator(
+        radius=radius, countSimulation=True, includeChirality=True, fpSize=fp_size
+    )
+    mol = Chem.MolFromSmiles(mol_smi)
+    uint_count_fp = fp_gen.GetCountFingerprint(mol)
+    count_fp = np.empty((1, fp_size), dtype=dtype)
+    DataStructs.ConvertToNumpyArray(uint_count_fp, count_fp)
+
+    return sparse.csr_matrix(count_fp, dtype=dtype)
+
+
+def mol_smi_to_count_fp(
+    mol_smi: str, radius: int = 2, fp_size: int = 2048, dtype: str = "int32"
+) -> sparse.csr_matrix:
+    mol = Chem.MolFromSmiles(mol_smi)
+    fp_bit = AllChem.GetMorganFingerprintAsBitVect(
+        mol,
+        radius=radius,
+        nBits=fp_size,
+        useChirality=True
+    )
+    fp = np.empty((1, fp_size), dtype=dtype)
+    DataStructs.ConvertToNumpyArray(fp_bit, fp)
+
+    return sparse.csr_matrix(fp, dtype=dtype)
+
+
+def get_model(args, device) -> Tuple[nn.Module, Dict[str, Any]]:
+    state = {}
+    if args.load_from:
+        misc.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"]
+        misc.log_args(pretrain_args, message="Logging pretraining args")
+
+        model = TemplRel(pretrain_args)
+        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)
+        misc.log_rank_0("Loaded pretrained model state_dict.")
+
+        # Overwrite for preprocessing during (likely) inference
+        args.fp_size = pretrain_args.fp_size
+        args.radius = pretrain_args.radius
+    else:
+        args.n_templates = sum(1 for _ in open(os.path.join(args.processed_data_path, "templates.jsonl")))
+        model = TemplRel(args)
+        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
+        )
+        misc.log_rank_0("DDP setup finished")
+
+    return model, state
+
+
+def save_reactions_from_list(
+    reactions: List[Dict[str, Any]],
+    template_set: str,
+    reaction_file_for_preprocessing: str,
+    reaction_file_for_db: str
+) -> None:
+    logging.info(f"Saving unique reactions for preprocessing to "
+                 f"{reaction_file_for_preprocessing}")
+
+    with open(reaction_file_for_preprocessing, "w") as of:
+        of.write("rxn_id,rxn_smiles\n")
+
+        for reaction in reactions:
+            of.write(f"{reaction['id']},{reaction['rxn_smiles']}\n")
+
+            reaction["reaction_id"] = reaction.pop("id")
+            reaction["reaction_smiles"] = reaction.pop("rxn_smiles")
+            if "_id" not in reaction:
+                reaction["_id"] = f"{template_set}_{reaction['reaction_id']}"
+            if "template_set" not in reaction:
+                reaction["template_set"] = template_set
+
+    logging.info(f"Saving reactions for db seeding to {reaction_file_for_db}")
+    with gzip.open(reaction_file_for_db, "wt", encoding="UTF-8") as zipfile:
+        json.dump(reactions, zipfile)
+
+    del reactions
+
+
+def save_templates_from_list(templates: List[Dict[str, Any]], template_file: str):
+    with open(template_file, "w") as of:
+        for template in templates:
+            if "rxn" in template:
+                del template["rxn"]
+            of.write(f"{json.dumps(template)}\n")
+
+
+def save_templates_from_dict(
+    templates: Dict[str, Dict[str, Any]],
+    template_file: str,
+    template_file_for_db: str
+) -> None:
+    templates_as_list = []
+
+    logging.info(f"Saving templates to {template_file}")
+    with open(template_file, "w") as of:
+        for canon_templ, metadata in templates.items():
+            assert metadata["reaction_smarts"] == canon_templ
+            if "rxn" in metadata:
+                del metadata["rxn"]
+            of.write(f"{json.dumps(metadata)}\n")
+
+            templates_as_list.append(metadata)
+
+    logging.info(f"Saving templates for db seeding to {template_file_for_db}")
+    with gzip.open(template_file_for_db, "wt", encoding="UTF-8") as zipfile:
+        json.dump(templates_as_list, zipfile)
+
+
+def load_templates_as_list(template_file: str
+                           ) -> Tuple[List[Dict[str, Any]], pd.DataFrame]:
+    templates = []
+    template_attributes = []
+
+    with open(template_file, "r") as f:
+        for line in f:
+            template = json.loads(line.strip())
+            del template["references"]
+
+            templates.append(template)
+            template_attributes.append(template.get("attributes", {}))
+    template_attributes = pd.DataFrame(template_attributes)
+
+    return templates, template_attributes
+
+
+def load_templates_as_dict(template_file: str) -> Dict[str, Dict[str, Any]]:
+    templates = {}
+
+    with open(template_file, "r") as f:
+        for line in f:
+            template = json.loads(line.strip())
+            templates[template["reaction_smarts"]] = template
+
+    return templates
+
+
+def get_lr(optimizer) -> float:
+    for param_group in optimizer.param_groups:
+        return param_group["lr"]
+
+
+def param_count(model: nn.Module) -> int:
+    return sum(param.numel() for param in model.parameters() if param.requires_grad)
+
+
+def param_norm(m: nn.Module) -> float:
+    return math.sqrt(sum([p.norm().item() ** 2 for p in m.parameters()]))
+
+
+def grad_norm(m: nn.Module) -> float:
+    return math.sqrt(sum([p.grad.norm().item() ** 2
+                          for p in m.parameters() if p.grad is not None]))

checkpoints/askcos_retro_template_relevance/uspto_higher_level/aux/mar_members.json

@@ -0,0 +1,52 @@
+{
+  "members": [
+    {
+      "compress_size": 2524,
+      "modified": "2026-04-17T19:55:38",
+      "path": "templ_rel_handler.py",
+      "size": 8685
+    },
+    {
+      "compress_size": 1251,
+      "modified": "2025-03-14T13:19:40",
+      "path": "templ_rel_parser.py",
+      "size": 5483
+    },
+    {
+      "compress_size": 1249,
+      "modified": "2023-11-02T19:58:44",
+      "path": "models.py",
+      "size": 4027
+    },
+    {
+      "compress_size": 786660005,
+      "modified": "2026-04-17T19:35:58",
+      "path": "model_latest.pt",
+      "size": 852483210
+    },
+    {
+      "compress_size": 2459,
+      "modified": "2025-03-14T13:19:40",
+      "path": "utils.py",
+      "size": 8103
+    },
+    {
+      "compress_size": 441,
+      "modified": "2023-11-02T19:58:44",
+      "path": "misc.py",
+      "size": 1062
+    },
+    {
+      "compress_size": 5641952,
+      "modified": "2026-04-17T19:30:02",
+      "path": "templates.jsonl",
+      "size": 26493635
+    },
+    {
+      "compress_size": 149,
+      "modified": "2026-04-17T19:56:06",
+      "path": "MAR-INF/MANIFEST.json",
+      "size": 215
+    }
+  ]
+}

checkpoints/askcos_retro_template_relevance/uspto_higher_level/aux/model_args.json

@@ -0,0 +1,40 @@
+{
+  "backend": "nccl",
+  "clip_norm": 20.0,
+  "data_name": "uspto_higher-level_consol",
+  "device": "cuda",
+  "dropout": 0.5,
+  "early_stop": true,
+  "early_stop_min_delta": 0.0001,
+  "early_stop_patience": 2,
+  "epochs": 150,
+  "fp_size": 2048,
+  "gating_activation": "sigmoid",
+  "hidden_activation": "relu",
+  "hidden_sizes": [
+    2048
+  ],
+  "is_optimistic_ranking": false,
+  "learning_rate": 0.00252468,
+  "load_from": "",
+  "local_rank": -1,
+  "log_file": "./logs/train/template_relevance_train_uspto_higher-level_consol.240806-1710h.log",
+  "lr_cooldown": 0,
+  "lr_scheduler_factor": 0.3,
+  "lr_scheduler_patience": 1,
+  "max_num_templ": 100,
+  "min_freq": 1,
+  "model_name": "template_relevance",
+  "model_path": "/home/jihye-roh/Higher_level_retrosynthesis/ASKCOSv2/retro/template_relevance/checkpoints/uspto_higher-level_consol",
+  "n_templates": 32622,
+  "num_cores": 32,
+  "processed_data_path": "/home/jihye-roh/Higher_level_retrosynthesis/ASKCOSv2/retro/template_relevance/data/uspto_higher-level_consol/processed",
+  "radius": 2,
+  "seed": 42,
+  "skip_connection": "none",
+  "test_batch_size": 2048,
+  "test_output_path": "",
+  "topk": 50,
+  "train_batch_size": 2048,
+  "val_batch_size": 2048
+}

checkpoints/askcos_retro_template_relevance/uspto_higher_level/aux/safetensors_conversion.json

@@ -0,0 +1,12 @@
+{
+  "format": "safetensors",
+  "num_tensors": 4,
+  "path": "model.safetensors",
+  "roundtrip_tensor_equal": true,
+  "runtime_assets": {
+    "model_args": "aux/model_args.json",
+    "templates": "aux/templates.jsonl"
+  },
+  "source_member": "model_latest.pt",
+  "status": "converted"
+}

checkpoints/askcos_retro_template_relevance/uspto_higher_level/benchmarks/metadata.json

@@ -0,0 +1,32 @@
+{
+  "benchmark_variant": "askcos_paroutes_compatibility_view",
+  "built_at": "1970-01-01T00:00:00+00:00",
+  "checkpoint_id": "uspto_higher_level",
+  "dataset_id": "askcos_retro_template_relevance_uspto_higher_level_paroutes_reference_route_test",
+  "dataset_ref": "paroutes2_reference_route_reactions",
+  "native_input_format": "tab_delimited_reactants_reagents_product_rows",
+  "native_sources": [
+    {
+      "notes": [
+        "Public PaRoutes selected_reactions.csv source table used to reconstruct the one-step reference-route reaction subset."
+      ],
+      "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"
+    },
+    {
+      "notes": [
+        "Public PaRoutes hash list identifying the reference-route reactions used here as a redistribution-safe ASKCOS compatibility benchmark."
+      ],
+      "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"
+    }
+  ],
+  "notes": [
+    "ASKCOS does not redistribute the native train/validation/test split for this TorchServe archive in datasets/modelos_ASKCOS.",
+    "This bundled benchmark is therefore a public PaRoutes one-step retrosynthesis compatibility view, not a claim about the model's original validation split."
+  ],
+  "num_examples": 56657,
+  "split": "test"
+}

checkpoints/askcos_retro_template_relevance/uspto_higher_level/manifest.json

@@ -0,0 +1,138 @@
+{
+  "auxiliary_files": [
+    "aux/MAR-INF/MANIFEST.json",
+    "aux/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl",
+    "benchmarks/default_test.jsonl",
+    "benchmarks/metadata.json",
+    "benchmarks/native/ref_routes_reaction_hashes.txt",
+    "benchmarks/native/selected_reactions.csv"
+  ],
+  "benchmark_datasets": [
+    {
+      "benchmark_variant": "askcos_paroutes_compatibility_view",
+      "dataset_id": "askcos_retro_template_relevance_uspto_higher_level_paroutes_reference_route_test",
+      "dataset_ref": "paroutes2_reference_route_reactions",
+      "default": true,
+      "format": "jsonl",
+      "metadata_path": "benchmarks/metadata.json",
+      "native_input_format": "tab_delimited_reactants_reagents_product_rows",
+      "native_source_paths": [
+        "benchmarks/native/selected_reactions.csv",
+        "benchmarks/native/ref_routes_reaction_hashes.txt"
+      ],
+      "notes": [
+        "ASKCOS does not redistribute the native train/validation/test split for this TorchServe archive in datasets/modelos_ASKCOS.",
+        "This bundled benchmark is therefore a public PaRoutes one-step retrosynthesis compatibility view, not a claim about the model's original validation split."
+      ],
+      "num_examples": 56657,
+      "path": "benchmarks/default_test.jsonl",
+      "split": "test"
+    }
+  ],
+  "checkpoint_id": "uspto_higher_level",
+  "contained_artifact_bindings": [
+    {
+      "canonical_split_family": "askcos_uspto_higher_level_split_unspecified",
+      "dataset_ref": "askcos_uspto_higher_level_release",
+      "path": "modelos_ASKCOS/mars/uspto_higher_level.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": 4,
+      "path": "model.safetensors",
+      "roundtrip_tensor_equal": true,
+      "runtime_assets": {
+        "model_args": "aux/model_args.json",
+        "templates": "aux/templates.jsonl"
+      },
+      "source_member": "model_latest.pt",
+      "status": "converted"
+    },
+    "source_format": "torchserve_mar_embedded_checkpoint",
+    "status": "converted",
+    "tool_version": "initial"
+  },
+  "display_name": "uspto_higher_level",
+  "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_template_relevance",
+  "model_role": "backward",
+  "normalized_checkpoint_id": "uspto_higher_level",
+  "package_layout": {
+    "aux_dir": "aux",
+    "benchmarks_dir": "benchmarks",
+    "weights_path": "model.safetensors"
+  },
+  "source_registry_refs": [
+    {
+      "checkpoint_id": "uspto_higher_level",
+      "model_id": "askcos_retro_template_relevance"
+    }
+  ],
+  "split_provenance": [
+    {
+      "canonical_split_family": "askcos_uspto_higher_level_split_unspecified",
+      "dataset_ref": "askcos_uspto_higher_level_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_uspto_higher_level_split_unspecified",
+      "dataset_ref": "askcos_uspto_higher_level_release",
+      "path": "modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "task_direction": "retrosynthesis",
+  "training_dataset_refs": [
+    "askcos_uspto_higher_level_release"
+  ],
+  "training_stage_bindings": [
+    {
+      "canonical_split_family": "askcos_uspto_higher_level_split_unspecified",
+      "dataset_ref": "askcos_uspto_higher_level_release",
+      "split_names": [],
+      "stage": "released_torchserve_archive"
+    },
+    {
+      "canonical_split_family": "askcos_uspto_higher_level_split_unspecified",
+      "dataset_ref": "askcos_uspto_higher_level_release",
+      "path": "modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "stage": "released_torchserve_archive"
+    }
+  ],
+  "weights": {
+    "dtype_summary": "float tensors preserved from upstream checkpoint",
+    "framework": "safetensors",
+    "path": "model.safetensors",
+    "tensor_namespace": "askcos_template_relevance"
+  },
+  "wrapper_config": "wrapper_config.json",
+  "wrapper_family": "askcos_template_relevance"
+}

checkpoints/askcos_retro_template_relevance/uspto_higher_level/provenance.json

@@ -0,0 +1,89 @@
+{
+  "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/mar_files/misc.py",
+    "aux/mar_files/models.py",
+    "aux/mar_files/templ_rel_handler.py",
+    "aux/mar_files/templ_rel_parser.py",
+    "aux/mar_files/utils.py",
+    "aux/mar_members.json",
+    "aux/model_args.json",
+    "aux/safetensors_conversion.json",
+    "aux/templates.jsonl"
+  ],
+  "inner_members": [
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "member": "templ_rel_handler.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "member": "templ_rel_parser.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "member": "models.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "member": "model_latest.pt",
+      "role": "weights_source"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "member": "utils.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "member": "misc.py",
+      "role": "archive_member"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "member": "templates.jsonl",
+      "role": "template_library"
+    },
+    {
+      "archive_path": "datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "member": "MAR-INF/MANIFEST.json",
+      "role": "torchserve_manifest"
+    }
+  ],
+  "normalized_checkpoint_id": "uspto_higher_level",
+  "source_artifacts": [
+    {
+      "absolute_path": "/mnt/HDD/syntheseus-bundle-builder/datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "kind": "local_repo_file",
+      "path": "datasets/modelos_ASKCOS/mars/uspto_higher_level.mar",
+      "role": "source_artifact",
+      "sha256": "fe746342007a4c767ceeab8c8dddcc7d73458d8a252e2587b83e50169f93b928",
+      "size": 792310888
+    },
+    {
+      "absolute_path": "/mnt/HDD/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": "/mnt/HDD/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_template_relevance/uspto_higher_level/wrapper_config.json

@@ -0,0 +1,37 @@
+{
+  "architecture_class": "NeuralSym-style template relevance FFN",
+  "device_supported": [
+    "cpu",
+    "cuda"
+  ],
+  "input_schema": {
+    "product_field": "smiles",
+    "request_format": {
+      "smiles": [
+        "product_smiles"
+      ]
+    },
+    "target_field": "reactants"
+  },
+  "license": "mit",
+  "loader": {
+    "kind": "askcos_template_relevance_safetensors",
+    "model_args": "aux/model_args.json",
+    "model_version": "1.0",
+    "served_model_name": "uspto_higher_level",
+    "source_handler": "templ_rel_handler.py",
+    "state_dict_format": "safetensors",
+    "templates": "aux/templates.jsonl"
+  },
+  "package_layout": {
+    "aux_dir": "aux",
+    "weights_path": "model.safetensors"
+  },
+  "runtime_file_map": {
+    "aux/model_args.json": "aux/model_args.json",
+    "aux/templates.jsonl": "aux/templates.jsonl",
+    "model.safetensors": "model.safetensors"
+  },
+  "task_direction": "retrosynthesis",
+  "wrapper_family": "askcos_template_relevance"
+}