Publish revised BERTose and BERToseBind release

Add the verified versioned scientific release and reader-facing documentation; preserve legacy files and history.

.gitattributes

@@ -6,3 +6,5 @@
 *.npz filter=lfs diff=lfs merge=lfs -text
 *.npy filter=lfs diff=lfs merge=lfs -text
 data/splits/train_val_split.json filter=lfs diff=lfs merge=lfs -text
+releases/2026-10-02/iar_completion/runtime_snapshot/java/review_MolWURCS.jar filter=lfs diff=lfs merge=lfs -text
+releases/2026-10-02/iar_completion/runtime_snapshot/java/review_wurcsframework-1.3.1.jar filter=lfs diff=lfs merge=lfs -text

README.md

@@ -2,103 +2,29 @@
 license: apache-2.0
 tags:
 - glycans
-- wurcs
 - bertose
-- affinose
-- reproducibility
-- training-code
-- pytorch
 ---
 
-# BERTose and AFFINose Training Code
+# BERTose and BERToseBind shared code
 
-This repository is the public training and reproducibility companion for the BERTose and AFFINose Hugging Face release. It contains the code, configs, tokenizer assets, split files, and provenance notes needed to understand how the released checkpoints were trained and evaluated.
+This repository preserves the original submission and provides the revised code once under [`releases/2026-10-02/`](releases/2026-10-02/README.md).
 
-The released inference checkpoints live separately:
+Start with the [shared workbench notebook](https://huggingface.co/supanthadey1/bertose-affinose-inference/blob/main/BERTose_workbench.ipynb) for sequence embeddings, BERToseBind prediction and supported IAR completion. The notebook uses this same code package and downloads only the required separately supplied model/data assets. You can download the notebook from its Hub page and open it in Jupyter or upload it into Google Colab.
 
-- BERTose glycan encoder: `supanthadey1/bertose-glycan-encoder`
-- BERTose IAR resolver: `supanthadey1/bertose-iar-resolver`
-- AFFINose interaction model: `supanthadey1/affinose-interaction-model`
-- Cloud inference notebook: `supanthadey1/bertose-affinose-inference`
-
-## Repository Map
-
-| Public workflow | Files |
-|---|---|
-| BERTose multimodal pretraining | `code/training/train_multimodal.py`, `code/training/multimodal_dataset.py`, `code/training/multimodal_masking.py`, `configs/` |
-| BERTose WURCS-BPE tokenizer training | `code/training/train_wurcs_bpe.py`, `code/model/wurcs_bpe_tokenizer.py`, `data/vocab/` |
-| BERTose IAR / contrastive refinement | `code/contrastive/`, `code/contrastive_training/`, `code/tokenizer/generate_bpe_ambiguity.py` |
-| AFFINose interaction training | `code/affinose/README.md` |
-| Benchmark reproduction | `code/benchmarks/`, `code/downstream_tasks/utils/` |
-| Embedding and biology probes | `code/probes/` |
-| Split and vocabulary assets | `data/splits/`, `data/vocab/` |
-| Compute and lineage provenance | `provenance/` |
-
-Some executable filenames and directories retain historical names so that provenance remains traceable to the original training runs. In public-facing text, use BERTose for the glycan encoder / IAR workflows and AFFINose for the protein-glycan interaction workflow.
-
-## What Is Included
-
-- Core BERTose architecture and dataset utilities.
-- BERTose multimodal pretraining entrypoint and configs.
-- WURCS-BPE tokenizer training and ambiguity-token generation code.
-- Contrastive refinement / IAR training and negative generation scripts.
-- AFFINose interaction-model data construction, split generation, training, and inference code.
-- Benchmark and probe scripts used for manuscript analyses.
-- Vocabulary files, ambiguity-token maps, train/validation split metadata, and leakage-exclusion lists.
-- Compute-provenance notes and representative launch scripts.
-
-## What Is Not Included
-
-Large training artifacts are intentionally not bundled here:
-
-- Full pretraining corpus pickles such as `sequences_bpe.pkl`.
-- Multi-GB intermediate mapping files.
-- Full training checkpoints; released checkpoints are hosted in the separate model repositories listed above.
-- ESM-C protein embeddings required for AFFINose training; users should generate or provide those separately according to the ESM-C access rules.
-
-## Quick Import Check
-
-After downloading the repository, a lightweight import check should work without access to the full training data:
+## Install locally
 
 ```bash
-cd code
-PYTHONDONTWRITEBYTECODE=1 python - <<'PY'
-import importlib
-
-for module in [
-    "training.multimodal_dataset",
-    "training.masking",
-    "training.multimodal_masking",
-    "training.train_multimodal",
-    "training.train_wurcs_bpe",
-    "model.dataset",
-    "downstream_tasks.utils.tokenizer",
-    "downstream_tasks.utils.wurcs_bpe_tokenizer",
-    "downstream_tasks.utils.dataset",
-]:
-    importlib.import_module(module)
-    print("ok", module)
-PY
+python3.12 -m venv .venv
+source .venv/bin/activate
+python -m pip install huggingface_hub==1.1.5
+hf download supanthadey1/bertose-affinose-training-code --repo-type model --revision main \
+  --include "releases/2026-10-02/*" --local-dir shared-code
+cd shared-code/releases/2026-10-02
+python -m pip install -r requirements-workbench.txt
 ```
 
-Full training requires the original large data artifacts and appropriate GPU resources.
-
-## Environment
-
-Install the core dependencies with:
-
-```bash
-pip install -r requirements.txt
-```
-
-Some probe scripts also use optional scientific plotting and glycan-analysis packages. See `requirements.txt` for the split between core and optional dependencies.
-
-## Reproducibility Notes
-
-- `MANIFEST.md` documents the file provenance and model-lineage mapping.
-- `RELEASE_AUDIT.md` documents the public-release state, fixed gaps, verification checks, and known scope limits.
-- Cluster launch scripts under `provenance/compute_provenance/` preserve the original compute context. They are provenance records, not portable one-command launchers for every environment.
+See the [package README](releases/2026-10-02/README.md) for the task commands and [reproduction instructions](releases/2026-10-02/docs/reproduction.md) for training entrypoints, additional input contracts and compute requirements. The complete sources, configurations, figures and execution evidence are preserved here. Portable inference checks do not establish a complete portable training or benchmark rerun.
 
-## License And Citation
+Model weights remain versioned under `releases/2026-09-28/` in the [encoder](https://huggingface.co/supanthadey1/bertose-glycan-encoder), [BERToseBind](https://huggingface.co/supanthadey1/affinose-interaction-model) and [IAR](https://huggingface.co/supanthadey1/bertose-iar-resolver) repositories. Shared data remain in [GlyCorpus](https://huggingface.co/datasets/supanthadey1/glycorpus). Their scientific-file hashes are recorded in the asset downloader configuration.
 
-This repository is released under the Apache License 2.0 as a research reproducibility companion for the BERTose and AFFINose manuscript. See `LICENSE`. Third-party dependencies and external models, including EvolutionaryScale ESM-C, retain their own licenses and access terms. Please cite the associated manuscript once available.
+Original code uses Apache-2.0 with preserved third-party notices and exceptions. Revised weights use Apache-2.0. Author-generated data use CC-BY-4.0; inherited inputs and ESM-C dependencies retain their own terms. See the versioned LICENSE, NOTICE and provenance manifest.

releases/2026-10-02/iar_completion/requirements.txt

@@ -0,0 +1,5 @@
+# Local artifact checks: Python 3.12.4, these already installed versions.
+# Historical final job: Python 3.10.16, torch 2.9.1+cu128; NumPy unrecorded.
+torch==2.9.1
+numpy==1.26.4
+tqdm>=4.0

releases/2026-10-02/iar_completion/runtime_dependencies.json

@@ -0,0 +1,280 @@
+{
+  "scope": "Static dependency audit of the unchanged final entrypoint; no full pipeline replay",
+  "final_source": "originals/wa3_final_iar_readout_all.py",
+  "top_level_external_packages": [
+    "numpy",
+    "torch"
+  ],
+  "transitive_direct_packages": [
+    "tqdm (submitted WA0 harness and distiller)"
+  ],
+  "external_executables": [
+    "java",
+    "javac"
+  ],
+  "imports": [
+    {
+      "module": "__future__",
+      "names": [
+        "annotations"
+      ],
+      "line": 111
+    },
+    {
+      "module": "base64",
+      "line": 113
+    },
+    {
+      "module": "builtins",
+      "line": 114
+    },
+    {
+      "module": "collections",
+      "line": 115
+    },
+    {
+      "module": "csv",
+      "line": 116
+    },
+    {
+      "module": "functools",
+      "line": 117
+    },
+    {
+      "module": "gzip",
+      "line": 118
+    },
+    {
+      "module": "hashlib",
+      "line": 119
+    },
+    {
+      "module": "importlib.util",
+      "line": 120
+    },
+    {
+      "module": "json",
+      "line": 121
+    },
+    {
+      "module": "os",
+      "line": 122
+    },
+    {
+      "module": "platform",
+      "line": 123
+    },
+    {
+      "module": "re",
+      "line": 124
+    },
+    {
+      "module": "shutil",
+      "line": 125
+    },
+    {
+      "module": "subprocess",
+      "line": 126
+    },
+    {
+      "module": "sys",
+      "line": 127
+    },
+    {
+      "module": "time",
+      "line": 128
+    },
+    {
+      "module": "pathlib",
+      "names": [
+        "Path"
+      ],
+      "line": 129
+    },
+    {
+      "module": "numpy",
+      "line": 131
+    },
+    {
+      "module": "torch",
+      "line": 132
+    },
+    {
+      "module": "frozen_training.a5_wurcs_bpe",
+      "line": 339
+    },
+    {
+      "module": "frozen_tree_runtime",
+      "line": 340
+    },
+    {
+      "module": "pipelib",
+      "names": [
+        "parse_record",
+        "SIDE_RE",
+        "node_index"
+      ],
+      "line": 521
+    },
+    {
+      "module": "classify",
+      "names": [
+        "PLAIN_LINK"
+      ],
+      "line": 522
+    }
+  ],
+  "path_bindings": [
+    {
+      "variable": "PROJ",
+      "source_expression": "Path(\"/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training\")",
+      "line": 137
+    },
+    {
+      "variable": "PKGD",
+      "source_expression": "PROJ / \"data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1\"",
+      "line": 138
+    },
+    {
+      "variable": "WA0_HARNESS",
+      "source_expression": "PROJ / \"writing/glycangt_heldout_ipa_validation/cluster/heldout_ipa_eval.py\"",
+      "line": 139
+    },
+    {
+      "variable": "WA0_VOCAB",
+      "source_expression": "PROJ / \"data/bpe_vocabulary_clean.json\"",
+      "line": 140
+    },
+    {
+      "variable": "WA0_AMB",
+      "source_expression": "PROJ / \"data/bpe_ambiguity_tokens.json\"",
+      "line": 141
+    },
+    {
+      "variable": "WA0_CKPT_PATH",
+      "source_expression": "PROJ / \"checkpoints_v5b_excluded/best_v5b_excluded_model.pt\"",
+      "line": 142
+    },
+    {
+      "variable": "BENCH_DIR",
+      "source_expression": "PROJ / \"writing/glycangt_heldout_ipa_validation\"",
+      "line": 143
+    },
+    {
+      "variable": "SCHEMA_DIR",
+      "source_expression": "Path(\"/work/ratul1/supantha/glycan-SD-VS/review/iar_pipe_schema_20260823_r1\")",
+      "line": 144
+    },
+    {
+      "variable": "JAVA_BIN",
+      "source_expression": "Path(\"/work/ratul1/supantha/miniconda3/envs/DeepGlycanSite/bin\")",
+      "line": 145
+    },
+    {
+      "variable": "ROOT",
+      "source_expression": "Path(\"/work/ratul1/supantha/bertose_a5_static_precache_20260723_r2c4_closure31_py310_3c8d5299a4af15bc\")",
+      "line": 146
+    },
+    {
+      "variable": "TRAIN_MOD",
+      "source_expression": "ROOT / (\"writing/review/multimodal/runtime/md_temporal_20x6_end_to_end_20260802_r3_native_intersection/\"\n                    \"run_review_md_temporal_20x6_training_r3.py\")",
+      "line": 147
+    },
+    {
+      "variable": "CK",
+      "source_expression": "ROOT / (\"writing/review/multimodal/outputs/a5_wa345_pretraining_20260817_r1/production/\"\n             \"review_md20x6_md20x6-a1111-wa345-20260817-r1_A1111_wa3_seed42/review_checkpoints/\"\n             \"review_md20x6_checkpoint_best.pt\")",
+      "line": 149
+    },
+    {
+      "variable": "WORK",
+      "source_expression": "Path(os.environ[\"WORK\"])",
+      "line": 154
+    },
+    {
+      "variable": "OUT",
+      "source_expression": "WORK / \"outputs\"",
+      "line": 156
+    },
+    {
+      "variable": "JAVA_DIR",
+      "source_expression": "WORK / \"inputs/java\"",
+      "line": 157
+    },
+    {
+      "variable": "SETS",
+      "source_expression": "{\n    \"bench1392\": {\"runs\": BENCH_RUNS, \"wa0_root\": BENCH_DIR / \"outputs\",\n                  \"baseline_runs\": [\"benchmark1392_residue_full\", \"benchmark1392_linkage_full\"]},\n    \"seal162\": {\"runs\": SEAL_RUNS, \"wa0_root\": WORK / \"inputs/wa0_seal\",\n                \"baseline_runs\": [\"seal162_residue_t080\", \"seal162_linkage_t080\"]},\n}",
+      "line": 182
+    }
+  ],
+  "dynamic_imports": [
+    {
+      "entry": "load_wa0_evaluator",
+      "path_variable": "WA0_HARNESS",
+      "included": "runtime_snapshot/project/writing/glycangt_heldout_ipa_validation/cluster/heldout_ipa_eval.py",
+      "transitive": [
+        "writing/cluster/nature_submission/code/training/ipa_bpe_distillation.py",
+        "writing/cluster/nature_submission/code/model/__init__.py",
+        "writing/cluster/nature_submission/code/model/multimodal_glycan_bert_v3.py",
+        "writing/cluster/nature_submission/code/model/glycan_bert.py",
+        "bert_training_v4/downstream_tasks/utils/wurcs_bpe_tokenizer.py"
+      ],
+      "scope": "Original harness imported and initialized with identity model in smoke check"
+    },
+    {
+      "entry": "build_wa3_tokenizer",
+      "included": "runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1",
+      "transitive": [
+        "three frozen Python sources",
+        "review_bpe_vocabulary.json",
+        "review_bpe_ambiguity_tokens.json",
+        "bert_training_v4/downstream_tasks/utils/wurcs_bpe_tokenizer.py"
+      ],
+      "scope": "Imports through generated temporary shim verified"
+    },
+    {
+      "entry": "load_achem",
+      "included": "runtime_snapshot/schema",
+      "transitive": [
+        "pipelib.py",
+        "classify.py"
+      ],
+      "scope": "Imports verified; these dependencies were not hash-pinned by final job"
+    },
+    {
+      "entry": "load_model",
+      "path_variable": "TRAIN_MOD",
+      "in_surrounding_code_package": "../bertose_source/writing/review/multimodal/runtime/md_temporal_20x6_end_to_end_20260802_r3_native_intersection/run_review_md_temporal_20x6_training_r3.py",
+      "transitive": "Native runtime imports and authority receipts in ../bertose_source; additional immutable external workspace inputs remain required",
+      "scope": "Not called in local checks because it loads the full encoder checkpoint"
+    }
+  ],
+  "external_data": [
+    {
+      "resource": "WA3 checkpoint",
+      "sha256": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+      "included": false
+    },
+    {
+      "resource": "Parent index and six training arrays",
+      "details": "provenance/required_input_hashes.json",
+      "included": false
+    },
+    {
+      "resource": "Benchmark and grey-seal CSVs",
+      "details": "provenance/final_run/run_manifest.json inputs",
+      "included": false
+    },
+    {
+      "resource": "Four original WA0 case_details.jsonl and summary.md pairs",
+      "runs": [
+        "benchmark1392_residue_full",
+        "benchmark1392_linkage_full",
+        "seal162_residue_t080",
+        "seal162_linkage_t080"
+      ],
+      "included": false
+    }
+  ],
+  "lineage_sources_are_runtime_imports": false,
+  "java_helper_compilation_checked": false
+}

releases/2026-10-02/iar_completion/runtime_snapshot/java/review_A5WurcsArrayTreeAudit.java

@@ -0,0 +1,467 @@
+package review.a5;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+
+import org.glycoinfo.WURCSFramework.util.array.WURCSImporter;
+import org.glycoinfo.WURCSFramework.wurcs.array.GLIP;
+import org.glycoinfo.WURCSFramework.wurcs.array.GLIPs;
+import org.glycoinfo.WURCSFramework.wurcs.array.LIN;
+import org.glycoinfo.WURCSFramework.wurcs.array.RES;
+import org.glycoinfo.WURCSFramework.wurcs.array.UniqueRES;
+import org.glycoinfo.WURCSFramework.wurcs.array.WURCSArray;
+
+/**
+ * Original-axis official WURCS adjudicator.
+ *
+ * <p>This helper deliberately uses WURCSImporter/WURCSArray rather than a
+ * normalized WURCSGraph.  RES list order is the sequence residue axis and
+ * every GLIP carries its explicit RESIndex, so no normalized-backbone
+ * permutation is applied to depth or topology targets.</p>
+ */
+public final class A5WurcsArrayTreeAudit {
+    private A5WurcsArrayTreeAudit() {}
+
+    private static final Base64.Decoder B64_DECODER = Base64.getUrlDecoder();
+    private static final Base64.Encoder B64_ENCODER =
+        Base64.getUrlEncoder().withoutPadding();
+
+    private static String b64(String value) {
+        return B64_ENCODER.encodeToString(value.getBytes(StandardCharsets.UTF_8));
+    }
+
+    private static String sha256(String value) throws Exception {
+        byte[] digest = MessageDigest.getInstance("SHA-256")
+            .digest(value.getBytes(StandardCharsets.UTF_8));
+        StringBuilder result = new StringBuilder(64);
+        for (byte item : digest) {
+            result.append(String.format("%02x", item & 0xff));
+        }
+        return result.toString();
+    }
+
+    private static boolean probabilityIsExact(GLIP linkage) {
+        return linkage.getBackboneProbabilityLower() == 1.0
+            && linkage.getBackboneProbabilityUpper() == 1.0
+            && linkage.getModificationProbabilityLower() == 1.0
+            && linkage.getModificationProbabilityUpper() == 1.0;
+    }
+
+    private static String pairKey(int left, int right) {
+        return Math.min(left, right) + ":" + Math.max(left, right);
+    }
+
+    private static String process(String rowIndex, String wurcs) throws Exception {
+        WURCSImporter importer = new WURCSImporter();
+        WURCSArray array = importer.extractWURCSArray(wurcs);
+        List<RES> residues = array.getRESs();
+        List<UniqueRES> uniqueResidues = array.getUniqueRESs();
+        List<LIN> linkages = array.getLINs();
+        int residueCount = residues.size();
+        if (residueCount == 0
+            || residueCount != array.getRESCount()
+            || linkages.size() != array.getLINCount()
+            || uniqueResidues.size() != array.getUniqueRESCount()) {
+            throw new IllegalStateException("official WURCSArray cardinality mismatch");
+        }
+
+        Map<String, Integer> residueIndex = new LinkedHashMap<>();
+        int[] anomericPositions = new int[residueCount];
+        List<String> residueLabels = new ArrayList<>();
+        List<String> uniqueIds = new ArrayList<>();
+        for (int index = 0; index < residueCount; index++) {
+            RES residue = residues.get(index);
+            String label = residue.getRESIndex();
+            if (label == null || label.isEmpty()
+                || residueIndex.put(label, index) != null) {
+                throw new IllegalStateException(
+                    "official RES indices are blank or duplicated"
+                );
+            }
+            int uniqueId = residue.getUniqueRESID();
+            if (uniqueId < 1 || uniqueId > uniqueResidues.size()) {
+                throw new IllegalStateException(
+                    "official RES references an invalid UniqueRES"
+                );
+            }
+            anomericPositions[index] =
+                uniqueResidues.get(uniqueId - 1).getAnomericPosition();
+            residueLabels.add(label);
+            uniqueIds.add(Integer.toString(uniqueId));
+        }
+
+        List<Set<Integer>> adjacency = new ArrayList<>();
+        List<List<Integer>> directedChildren = new ArrayList<>();
+        for (int index = 0; index < residueCount; index++) {
+            adjacency.add(new HashSet<>());
+            directedChildren.add(new ArrayList<>());
+        }
+        Map<Integer, Integer> childParent = new HashMap<>();
+        Set<String> seenPairs = new HashSet<>();
+        List<String> pairRecords = new ArrayList<>();
+        int connectorCount = 0;
+        int monovalentCount = 0;
+        int repeatCount = 0;
+        int alternativeGroupCount = 0;
+        int residueIdentityAmbiguousGroupCount = 0;
+        int sameResidueAlternativeGroupCount = 0;
+        int groupedPositionGroupCount = 0;
+        int probabilityEndpointCount = 0;
+        int unknownBackbonePositionCount = 0;
+        int unknownModificationPositionCount = 0;
+        int unknownDirectionCount = 0;
+        int mapConnectorCount = 0;
+        int hyperedgeCount = 0;
+        int duplicatePairCount = 0;
+        int orientationFailureCount = 0;
+        int groupedOrientationNonInvariantCount = 0;
+        String topologyBlocker = "";
+        String rootedBlocker = "";
+        StringBuilder serialization = new StringBuilder();
+
+        if (array.isComposition()) {
+            topologyBlocker = "official_composition_record";
+        }
+
+        for (int linkageIndex = 0;
+             linkageIndex < linkages.size();
+             linkageIndex++) {
+            LIN linkage = linkages.get(linkageIndex);
+            if (linkage.isRepeatingUnit()) {
+                repeatCount++;
+            }
+            Map<Integer, List<GLIP>> byResidue = new LinkedHashMap<>();
+            boolean groupIdentityUncertain = false;
+            boolean connectorProbability = false;
+            for (GLIPs group : linkage.getListOfGLIPs()) {
+                boolean officialAlternative =
+                    group.getAlternativeType() != null;
+                if (officialAlternative) {
+                    alternativeGroupCount++;
+                }
+                if (group.getGLIPs().size() > 1) {
+                    groupedPositionGroupCount++;
+                }
+                Set<Integer> groupResidues = new HashSet<>();
+                for (GLIP endpoint : group.getGLIPs()) {
+                    Integer index = residueIndex.get(endpoint.getRESIndex());
+                    if (index == null) {
+                        throw new IllegalStateException(
+                            "official GLIP references an unknown RESIndex"
+                        );
+                    }
+                    groupResidues.add(index);
+                    byResidue.computeIfAbsent(
+                        index, ignored -> new ArrayList<>()
+                    ).add(endpoint);
+                    if (!probabilityIsExact(endpoint)) {
+                        probabilityEndpointCount++;
+                        connectorProbability = true;
+                    }
+                    if (endpoint.getBackbonePosition() < 1) {
+                        unknownBackbonePositionCount++;
+                    }
+                    if (endpoint.getModificationPosition() < 0) {
+                        unknownModificationPositionCount++;
+                    }
+                    char direction = endpoint.getBackboneDirection();
+                    if (direction == '?' || direction == 'x'
+                        || direction == 'X') {
+                        unknownDirectionCount++;
+                    }
+                }
+                if (groupResidues.size() != 1) {
+                    groupIdentityUncertain = true;
+                    residueIdentityAmbiguousGroupCount++;
+                } else if (officialAlternative) {
+                    /*
+                     * Official ``{``/``}`` marks an alternative lead-out or
+                     * lead-in GLIPs group.  It does not by itself make the
+                     * residue identity uncertain.  If every endpoint in the
+                     * group names the same RES, undirected residue adjacency
+                     * remains exact; only attachment chemistry and, unless
+                     * every endpoint has the same donor status, rooting are
+                     * uncertain.
+                     */
+                    sameResidueAlternativeGroupCount++;
+                }
+            }
+
+            int degree = byResidue.size();
+            if (degree <= 1) {
+                monovalentCount++;
+                if (linkage.isRepeatingUnit() && topologyBlocker.isEmpty()) {
+                    topologyBlocker = "official_repeat_record";
+                }
+                continue;
+            }
+            if (linkage.isRepeatingUnit() && topologyBlocker.isEmpty()) {
+                topologyBlocker = "official_repeat_connector";
+            }
+            if (groupIdentityUncertain && topologyBlocker.isEmpty()) {
+                topologyBlocker = "residue_identity_ambiguous_connector";
+            }
+            if (degree != 2) {
+                hyperedgeCount++;
+                if (topologyBlocker.isEmpty()) {
+                    topologyBlocker = "connector_residue_degree_not_two";
+                }
+                continue;
+            }
+            if (connectorProbability && topologyBlocker.isEmpty()) {
+                topologyBlocker = "probabilistic_connector_endpoint";
+            }
+
+            List<Integer> linked = new ArrayList<>(byResidue.keySet());
+            Collections.sort(linked);
+            int left = linked.get(0);
+            int right = linked.get(1);
+            String pair = pairKey(left, right);
+            pairRecords.add(left + "-" + right);
+            connectorCount++;
+            if (!seenPairs.add(pair)) {
+                duplicatePairCount++;
+                if (topologyBlocker.isEmpty()) {
+                    topologyBlocker = "duplicate_residue_pair_connector";
+                }
+            }
+            adjacency.get(left).add(right);
+            adjacency.get(right).add(left);
+            String mapCode = linkage.getMAPCode();
+            if (mapCode != null && !mapCode.isEmpty()) {
+                mapConnectorCount++;
+            }
+
+            Map<Integer, Boolean> donorByResidue = new HashMap<>();
+            boolean orientationConsistent = true;
+            for (int residue : linked) {
+                Boolean donor = null;
+                boolean grouped = byResidue.get(residue).size() > 1;
+                for (GLIP endpoint : byResidue.get(residue)) {
+                    int position = endpoint.getBackbonePosition();
+                    int anomeric = anomericPositions[residue];
+                    if (position < 1 || anomeric < 0) {
+                        orientationConsistent = false;
+                        continue;
+                    }
+                    boolean endpointDonor = anomeric > 0
+                        && position == anomeric;
+                    if (donor != null
+                        && donor.booleanValue() != endpointDonor) {
+                        orientationConsistent = false;
+                        if (grouped) {
+                            groupedOrientationNonInvariantCount++;
+                        }
+                    }
+                    donor = endpointDonor;
+                }
+                if (donor == null) {
+                    orientationConsistent = false;
+                } else {
+                    donorByResidue.put(residue, donor);
+                }
+            }
+            boolean leftDonor = Boolean.TRUE.equals(donorByResidue.get(left));
+            boolean rightDonor = Boolean.TRUE.equals(donorByResidue.get(right));
+            if (!orientationConsistent || leftDonor == rightDonor) {
+                orientationFailureCount++;
+                if (rootedBlocker.isEmpty()) {
+                    rootedBlocker = "official_donor_not_unique";
+                }
+            } else {
+                int child = leftDonor ? left : right;
+                int parent = leftDonor ? right : left;
+                Integer previous = childParent.putIfAbsent(child, parent);
+                if (previous != null && previous.intValue() != parent) {
+                    orientationFailureCount++;
+                    if (rootedBlocker.isEmpty()) {
+                        rootedBlocker = "residue_has_multiple_parents";
+                    }
+                }
+                directedChildren.get(parent).add(child);
+            }
+            serialization.append(linkageIndex).append(':')
+                .append(left).append('-').append(right).append(':')
+                .append(leftDonor).append('-').append(rightDonor).append(':')
+                .append(mapCode == null ? "NULL" : mapCode).append('\n');
+        }
+
+        if (repeatCount > 0 && topologyBlocker.isEmpty()) {
+            topologyBlocker = "official_repeat_record";
+        }
+        if (connectorCount != residueCount - 1 && topologyBlocker.isEmpty()) {
+            topologyBlocker = "edge_count_not_residue_count_minus_one";
+        }
+
+        Set<Integer> visited = new HashSet<>();
+        Queue<Integer> queue = new ArrayDeque<>();
+        visited.add(0);
+        queue.add(0);
+        while (!queue.isEmpty()) {
+            int current = queue.remove();
+            for (int neighbor : adjacency.get(current)) {
+                if (visited.add(neighbor)) {
+                    queue.add(neighbor);
+                }
+            }
+        }
+        boolean connected = visited.size() == residueCount;
+        if (!connected && topologyBlocker.isEmpty()) {
+            topologyBlocker = "residue_graph_disconnected";
+        }
+        boolean exactUndirectedTree = topologyBlocker.isEmpty();
+
+        List<Integer> depths = new ArrayList<>();
+        int maxDepth = -1;
+        if (!exactUndirectedTree && rootedBlocker.isEmpty()) {
+            rootedBlocker = topologyBlocker;
+        }
+        if (rootedBlocker.isEmpty()) {
+            Set<Integer> roots = new HashSet<>();
+            for (int index = 0; index < residueCount; index++) {
+                if (!childParent.containsKey(index)) {
+                    roots.add(index);
+                }
+            }
+            if (roots.size() != 1) {
+                rootedBlocker = "root_not_unique";
+            } else {
+                int[] values = new int[residueCount];
+                for (int index = 0; index < residueCount; index++) {
+                    values[index] = -1;
+                }
+                int root = roots.iterator().next();
+                values[root] = 0;
+                queue.clear();
+                queue.add(root);
+                while (!queue.isEmpty() && rootedBlocker.isEmpty()) {
+                    int parent = queue.remove();
+                    for (int child : directedChildren.get(parent)) {
+                        if (values[child] >= 0) {
+                            rootedBlocker = "directed_cycle_or_duplicate_child";
+                            break;
+                        }
+                        values[child] = values[parent] + 1;
+                        queue.add(child);
+                    }
+                }
+                for (int value : values) {
+                    if (value < 0 && rootedBlocker.isEmpty()) {
+                        rootedBlocker = "directed_tree_disconnected";
+                    }
+                    depths.add(value);
+                    maxDepth = Math.max(maxDepth, value);
+                }
+            }
+        }
+        boolean exactRootedTree = exactUndirectedTree && rootedBlocker.isEmpty();
+        if (!exactRootedTree) {
+            depths.clear();
+            maxDepth = -1;
+        }
+        StringBuilder depthText = new StringBuilder();
+        for (int index = 0; index < depths.size(); index++) {
+            if (index > 0) {
+                depthText.append(',');
+            }
+            depthText.append(depths.get(index));
+        }
+        Collections.sort(pairRecords);
+        String pairText = exactUndirectedTree
+            ? String.join(",", pairRecords) : "";
+        StringBuilder parentText = new StringBuilder();
+        if (exactRootedTree) {
+            for (int index = 0; index < residueCount; index++) {
+                if (index > 0) {
+                    parentText.append(',');
+                }
+                parentText.append(childParent.getOrDefault(index, -1));
+            }
+        }
+        String residueOrder = String.join(",", residueLabels);
+        String uniqueOrder = String.join(",", uniqueIds);
+        String axisProof = residueOrder + "\n" + uniqueOrder;
+
+        return String.join("\t",
+            rowIndex,
+            "OK",
+            Integer.toString(residueCount),
+            Integer.toString(linkages.size()),
+            Integer.toString(connectorCount),
+            Integer.toString(monovalentCount),
+            Integer.toString(repeatCount),
+            Integer.toString(alternativeGroupCount),
+            Integer.toString(groupedPositionGroupCount),
+            Integer.toString(probabilityEndpointCount),
+            Integer.toString(unknownBackbonePositionCount),
+            Integer.toString(unknownModificationPositionCount),
+            Integer.toString(unknownDirectionCount),
+            Integer.toString(mapConnectorCount),
+            Integer.toString(hyperedgeCount),
+            Integer.toString(duplicatePairCount),
+            Integer.toString(orientationFailureCount),
+            Integer.toString(groupedOrientationNonInvariantCount),
+            Boolean.toString(connected),
+            Boolean.toString(exactUndirectedTree),
+            Boolean.toString(exactRootedTree),
+            b64(topologyBlocker),
+            b64(rootedBlocker),
+            Integer.toString(maxDepth),
+            b64(depthText.toString()),
+            b64(pairText),
+            b64(parentText.toString()),
+            b64(residueOrder),
+            b64(uniqueOrder),
+            sha256(serialization.toString()),
+            sha256(wurcs),
+            sha256(axisProof),
+            Integer.toString(residueIdentityAmbiguousGroupCount),
+            Integer.toString(sameResidueAlternativeGroupCount)
+        );
+    }
+
+    public static void main(String[] args) throws Exception {
+        try (BufferedReader reader = new BufferedReader(
+            new InputStreamReader(System.in, StandardCharsets.UTF_8)
+        )) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                if (line.isEmpty()) {
+                    continue;
+                }
+                String[] fields = line.split("\t", -1);
+                String rowIndex = fields.length > 0 ? fields[0] : "";
+                try {
+                    if (fields.length != 2 || rowIndex.isEmpty()) {
+                        throw new IllegalArgumentException(
+                            "input must be row_index and base64 WURCS"
+                        );
+                    }
+                    String wurcs = new String(
+                        B64_DECODER.decode(fields[1]), StandardCharsets.UTF_8
+                    );
+                    System.out.println(process(rowIndex, wurcs));
+                } catch (Exception error) {
+                    String message = error.getClass().getName() + ": "
+                        + error.getMessage();
+                    System.out.println(
+                        rowIndex + "\tERROR\t" + b64(message)
+                    );
+                }
+            }
+        }
+    }
+}

releases/2026-10-02/iar_completion/runtime_snapshot/java/review_MolWURCS.jar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc38e44e66daed7ec04f7c7907a13509aac125a8a09c97d9972725ab4278edaf
+size 4019920

releases/2026-10-02/iar_completion/runtime_snapshot/java/review_wurcsframework-1.3.1.jar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5449f9276a7b952adf087468c874bb13c7295062cce7d1afb13fdea78ace7f37
+size 340319

releases/2026-10-02/iar_completion/runtime_snapshot/project/bert_training_v4/downstream_tasks/utils/wurcs_bpe_tokenizer.py

@@ -0,0 +1,740 @@
+#!/usr/bin/env python3
+"""
+WURCS-BPE Tokenizer
+
+A hybrid tokenizer that learns semantic subwords from WURCS while preserving
+the ability to handle rare/novel glycan structures character-by-character.
+
+Key features:
+1. Pre-tokenization: Split WURCS into semantic units (residues, linkages, mods)
+2. BPE: Learn subword merges from corpus
+3. Character fallback: Handle novel structures
+4. Tree embeddings: Preserve branch_depth and linkage_type per token
+
+Usage:
+    # Train BPE on corpus
+    tokenizer = WURCSBPETokenizer.train_from_corpus(
+        wurcs_strings, 
+        num_merges=500,
+        output_path="bpe_vocabulary.json"
+    )
+    
+    # Tokenize
+    result = tokenizer.tokenize(wurcs_string)
+"""
+
+import json
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Set
+import pickle
+
+
+class WURCSPreTokenizer:
+    """
+    Pre-tokenize WURCS into semantic units before BPE.
+    
+    WURCS format: WURCS=2.0/count/[residues]/indices/linkages
+    
+    We split into:
+    - Residues: [a2122h-1b_1-5_2*NCC/3=O] -> one unit per []
+    - Linkages: a4-b1 -> one unit per linkage
+    - Special markers: [BRANCH_OPEN], [BRANCH_CLOSE], etc.
+    """
+    
+    # Residue patterns for common monosaccharides
+    RESIDUE_PATTERN = re.compile(r'\[([^\]]+)\]')
+    LINKAGE_PATTERN = re.compile(r'([a-z])(\d+|\?)-([a-z])(\d+|\?)')
+    
+    def __init__(self):
+        self.special_tokens = {
+            '[PAD]': 0,
+            '[UNK]': 1,
+            '[START]': 2,
+            '[END]': 3,
+            '[MASK]': 4,
+            '[BRANCH_OPEN]': 5,
+            '[BRANCH_CLOSE]': 6,
+            '[LINK]': 7,
+            '[MOD]': 8,
+            '[RESIDUE_ERROR]': 9,
+        }
+    
+    def pre_tokenize(self, wurcs: str) -> List[Dict]:
+        """
+        Pre-tokenize WURCS into semantic units.
+        
+        Returns list of dicts with:
+            - text: The unit text
+            - type: 'special', 'residue', 'linkage', 'mod', 'index'
+            - residue_id: Which residue this belongs to (-1 for special, -2 for linkage)
+            - branch_depth: Tree depth (computed later)
+        """
+        units = []
+        
+        # Add start token
+        units.append({
+            'text': '[START]',
+            'type': 'special',
+            'residue_id': -1,
+            'branch_depth': 0,
+            'linkage_type': 0,
+        })
+        
+        # Parse WURCS sections
+        if not wurcs.startswith('WURCS='):
+            units.append({'text': '[RESIDUE_ERROR]', 'type': 'special', 'residue_id': -1, 'branch_depth': 0, 'linkage_type': 0})
+            units.append({'text': '[END]', 'type': 'special', 'residue_id': -1, 'branch_depth': 0, 'linkage_type': 0})
+            return units
+        
+        try:
+            parts = self._split_wurcs_sections(wurcs)
+            if len(parts) < 4:
+                return [{'text': '[ERROR]', 'type': 'special', 'residue_id': -1, 'branch_depth': 0, 'linkage_type': 0}]
+            
+            # parts: WURCS=2.0/3,3,2/[a2122h-1b_1-5][a2122h-1a_1-5][a1122h-1b_1-5]/1-2-3-1/a4-b1_b3-c1_c4-d1
+            # section 2: residue definitions
+            # section 3: indices
+            # section 4: linkages (optional)
+            
+            version = parts[0]  # WURCS=2.0
+            counts = parts[1]   # residue_count,node_count,link_count
+            residue_defs = parts[2]  # [res1][res2]...
+            indices = parts[3]  # 1-2-3-1
+            linkages = parts[4] if len(parts) > 4 else ""  # a4-b1_b3-c1
+            
+            # Parse residue definitions
+            residue_list = self.RESIDUE_PATTERN.findall(residue_defs)
+            
+            # Parse linkages to compute branch structure
+            linkage_list = linkages.split('_') if linkages else []
+            branch_points, residue_depths, linkage_types_map, adj = self._analyze_tree_structure(linkage_list, num_residues=len(residue_list))
+            
+            # Compute distance matrix and cache it based on the linkage string (structure)
+            # This is the most expensive part, so we cache it
+            if not hasattr(self, '_dist_cache'): self._dist_cache = {}
+            if linkages not in self._dist_cache:
+                self._dist_cache[linkages] = self._compute_distance_matrix(adj, len(residue_list))
+            dist_matrix_raw = self._dist_cache[linkages]
+            
+            # Parse indices to map positions to residue definitions
+            index_list = indices.split('-') if indices else []
+            
+            # Process each residue instance
+            residue_letter = ord('a')
+            for idx, res_idx in enumerate(index_list):
+                current_residue_id = idx
+                res_letter = chr(residue_letter + idx)
+                
+                # Check if this is a branch point - add branch marker before
+                if res_letter in branch_points and branch_points[res_letter] > 0:
+                    for _ in range(branch_points[res_letter]):
+                        units.append({
+                            'text': '[BRANCH_OPEN]',
+                            'type': 'special',
+                            'residue_id': -1,
+                            'branch_depth': residue_depths.get(res_letter, 0),
+                            'linkage_type': 0,
+                        })
+                
+                # Get residue definition
+                try:
+                    res_def_idx = int(res_idx) - 1  # 1-indexed to 0-indexed
+                    res_def = residue_list[res_def_idx] if res_def_idx < len(residue_list) else ""
+                except (ValueError, IndexError):
+                    res_def = ""
+                
+                # Split residue into base and modifications
+                res_parts = res_def.split('_')
+                base = res_parts[0] if res_parts else res_def
+                mods = res_parts[1:] if len(res_parts) > 1 else []
+                
+                # Add residue base as a single unit
+                depth = residue_depths.get(res_letter, 0)
+                units.append({
+                    'text': base,
+                    'type': 'residue',
+                    'residue_id': current_residue_id,
+                    'branch_depth': depth,
+                    'linkage_type': 0,
+                })
+                
+                # Add modifications
+                for mod in mods:
+                    units.append({
+                        'text': mod,
+                        'type': 'mod',
+                        'residue_id': current_residue_id,
+                        'branch_depth': depth,
+                        'linkage_type': 0,
+                    })
+            
+            # Store distance matrix in units for easy access in tokenizer
+            if units:
+                # Find first residue unit or just use START
+                units[0]['distance_matrix'] = dist_matrix_raw
+            
+            # Add linkages
+            for link in linkage_list:
+                if not link:
+                    continue
+                # Parse linkage type
+                lt = self._parse_linkage_type(link)
+                units.append({
+                    'text': link,
+                    'type': 'linkage',
+                    'residue_id': -2,
+                    'branch_depth': 0,
+                    'linkage_type': lt,
+                })
+        except Exception:
+            # Fallback for truly broken WURCS
+            pass
+        
+        # Add end token
+        units.append({
+            'text': '[END]',
+            'type': 'special',
+            'residue_id': -1,
+            'branch_depth': 0,
+            'linkage_type': 0,
+        })
+        
+        return units
+    
+    def _split_wurcs_sections(self, wurcs: str) -> List[str]:
+        """Split WURCS string into sections, handling nested brackets."""
+        # Remove WURCS= prefix
+        if wurcs.startswith('WURCS='):
+            wurcs = wurcs[6:]
+        
+        sections = []
+        current = ""
+        bracket_depth = 0
+        
+        for char in wurcs:
+            if char == '[':
+                bracket_depth += 1
+                current += char
+            elif char == ']':
+                bracket_depth -= 1
+                current += char
+            elif char == '/' and bracket_depth == 0:
+                sections.append(current)
+                current = ""
+            else:
+                current += char
+        
+        if current:
+            sections.append(current)
+        
+        return sections
+    
+    def _analyze_tree_structure(self, linkages: List[str], num_residues: int) -> Tuple[Dict, Dict, Dict, Dict]:
+        """Analyze linkages to compute branch points and residue depths."""
+        branch_points = defaultdict(int)  # residue -> number of children
+        children = defaultdict(list)
+        all_residues = set()
+        linkage_types = {}
+        
+        for link in linkages:
+            match = self.LINKAGE_PATTERN.match(link)
+            if match:
+                from_res, from_pos, to_res, to_pos = match.groups()
+                children[from_res].append(to_res)
+                all_residues.add(from_res)
+                all_residues.add(to_res)
+                
+                # Store linkage type
+                linkage_types[link] = self._parse_linkage_type(link)
+        
+        # Build adjacency list for BFS
+        adj = defaultdict(list)
+        for link in linkages:
+            match = self.LINKAGE_PATTERN.match(link)
+            if match:
+                u = ord(match.group(1)) - ord('a')
+                v = ord(match.group(3)) - ord('a')
+                if 0 <= u < num_residues and 0 <= v < num_residues:
+                    adj[u].append(v)
+                    adj[v].append(u)
+        
+        # Find branch points (residues with >1 child)
+        for res, kids in children.items():
+            if len(kids) > 1:
+                branch_points[res] = len(kids) - 1  # Number of extra branches
+        
+        # Compute depths using BFS
+        # Find root (residue with no parent)
+        child_set = set()
+        for kids in children.values():
+            child_set.update(kids)
+        roots = all_residues - child_set
+        root = min(roots) if roots else 'a'
+        
+        depths = {root: 0}
+        queue = [root]
+        while queue:
+            current = queue.pop(0)
+            for child in children.get(current, []):
+                if child not in depths:
+                    depths[child] = depths[current] + 1
+                    queue.append(child)
+        
+        return branch_points, depths, linkage_types, adj
+    
+    def _compute_distance_matrix(self, adj: Dict[int, List[int]], num_residues: int) -> List[List[int]]:
+        """
+        Compute shortest path distance (number of bonds) between all residue pairs using BFS.
+        """
+        if num_residues == 0:
+            return []
+            
+        dist_matrix = [[-1] * num_residues for _ in range(num_residues)]
+        
+        for i in range(num_residues):
+            dist_matrix[i][i] = 0
+            queue = [(i, 0)]
+            visited = {i}
+            
+            while queue:
+                curr, d = queue.pop(0)
+                dist_matrix[i][curr] = d
+                
+                for neighbor in adj[curr]:
+                    if neighbor not in visited:
+                        visited.add(neighbor)
+                        queue.append((neighbor, d + 1))
+                        
+        return dist_matrix
+             
+    def _compute_distance_matrix_OLD(self, linkages: List[str], num_residues: int) -> List[List[int]]:
+        """
+        Compute shortest path distance (number of bonds) between all residue pairs.
+        Returns a symmetric N x N matrix where N is num_residues.
+        Values are integers (number of steps). 0 on diagonal. -1 if unreachable (shouldn't happen in single tree).
+        """
+        if num_residues == 0:
+            return []
+            
+        # Initialize adjacency list
+        adj = defaultdict(list)
+        for link in linkages:
+            match = self.LINKAGE_PATTERN.match(link)
+            if match:
+                # WURCS indices are 1-based letters (a=1, b=2...)
+                from_res_char, _, to_res_char, _ = match.groups()
+                # Convert char to 0-based index
+                u = ord(from_res_char) - ord('a')
+                v = ord(to_res_char) - ord('a')
+                
+                # Undirected graph for structural distance
+                if 0 <= u < num_residues and 0 <= v < num_residues:
+                    adj[u].append(v)
+                    adj[v].append(u)
+                    
+        # Compute All-Pairs Shortest Path (BFS from each node is fine for small N)
+        # Glycans are small (N ~ 5-20 usually), so O(N^2) BFS is cheap.
+        dist_matrix = [[-1] * num_residues for _ in range(num_residues)]
+        
+        for i in range(num_residues):
+            dist_matrix[i][i] = 0
+            queue = [(i, 0)]
+            visited = {i}
+            
+            while queue:
+                curr, d = queue.pop(0)
+                dist_matrix[i][curr] = d
+                
+                for neighbor in adj[curr]:
+                    if neighbor not in visited:
+                        visited.add(neighbor)
+                        queue.append((neighbor, d + 1))
+                        
+        return dist_matrix
+    
+    def _parse_linkage_type(self, link: str) -> int:
+        """Parse linkage string to get type ID."""
+        LINKAGE_TYPES = {
+            (1, 2): 0, (2, 1): 0,
+            (1, 3): 1, (3, 1): 1,
+            (1, 4): 2, (4, 1): 2,
+            (1, 6): 3, (6, 1): 3,
+            (2, 3): 4, (3, 2): 4,
+            (2, 6): 5, (6, 2): 5,
+            (3, 6): 6, (6, 3): 6,
+        }
+        
+        match = self.LINKAGE_PATTERN.match(link)
+        if match:
+            _, from_pos, _, to_pos = match.groups()
+            try:
+                pos_tuple = (int(from_pos), int(to_pos))
+                return LINKAGE_TYPES.get(pos_tuple, 7)
+            except ValueError:
+                return 8  # Unknown
+        return 8
+
+
+class WURCSBPETokenizer:
+    """
+    BPE tokenizer for WURCS with tree-aware embeddings.
+    """
+    
+    def __init__(self, vocab_path: Optional[str] = None):
+        self.pre_tokenizer = WURCSPreTokenizer()
+        
+        # Special tokens (fixed)
+        self.special_tokens = self.pre_tokenizer.special_tokens
+        
+        # BPE vocabulary
+        self.token_to_id: Dict[str, int] = {}
+        self.id_to_token: Dict[int, str] = {}
+        self.merges: List[Tuple[str, str]] = []
+        
+        if vocab_path:
+            self.load_vocab(vocab_path)
+        else:
+            # Initialize with special tokens only
+            self.token_to_id = dict(self.special_tokens)
+            self.id_to_token = {v: k for k, v in self.token_to_id.items()}
+    
+    @classmethod
+    def train_from_corpus(
+        cls, 
+        wurcs_strings: List[str], 
+        num_merges: int = 500,
+        output_path: Optional[str] = None,
+        min_frequency: int = 2,
+        max_token_length: Optional[int] = None,
+    ) -> 'WURCSBPETokenizer':
+        """
+        Train BPE on a corpus of WURCS strings.
+        
+        Args:
+            wurcs_strings: List of WURCS strings
+            num_merges: Number of BPE merge operations
+            output_path: Optional path to save vocabulary
+            min_frequency: Minimum frequency for a token to be kept
+            max_token_length: Maximum length of a merged token (None = no limit)
+        
+        Returns:
+            Trained tokenizer
+        """
+        tokenizer = cls()
+        pre_tok = WURCSPreTokenizer()
+        
+        print(f"Training BPE on {len(wurcs_strings)} WURCS strings...")
+        
+        # Step 1: Pre-tokenize all strings to get semantic units
+        all_units = []
+        for wurcs in wurcs_strings:
+            units = pre_tok.pre_tokenize(wurcs)
+            for unit in units:
+                if unit['type'] != 'special':
+                    all_units.append(unit['text'])
+        
+        # Step 2: Count unit frequencies
+        unit_counts = Counter(all_units)
+        print(f"Found {len(unit_counts)} unique units")
+        
+        # Step 3: Initialize vocabulary with characters from all units
+        char_vocab = set()
+        for unit in unit_counts:
+            for char in unit:
+                char_vocab.add(char)
+        
+        # Build initial vocab: special tokens + characters
+        vocab_id = len(tokenizer.special_tokens)
+        for char in sorted(char_vocab):
+            tokenizer.token_to_id[char] = vocab_id
+            tokenizer.id_to_token[vocab_id] = char
+            vocab_id += 1
+        
+        print(f"Initial vocab size: {vocab_id} (special + characters)")
+        
+        # Step 4: Convert units to character sequences
+        word_freqs = {}
+        for unit, count in unit_counts.items():
+            if count >= min_frequency:
+                # Split into characters with space separator
+                chars = tuple(unit)
+                word_freqs[chars] = count
+        
+        # Step 5: BPE merging
+        merges = []
+        
+        for merge_idx in range(num_merges):
+            # Count pairs
+            pair_counts = Counter()
+            for word, freq in word_freqs.items():
+                for i in range(len(word) - 1):
+                    pair = (word[i], word[i + 1])
+                    pair_counts[pair] += freq
+            
+            if not pair_counts:
+                break
+            
+            # Find most frequent pair
+            best_pair = pair_counts.most_common(1)[0][0]
+            best_count = pair_counts[best_pair]
+            
+            if best_count < min_frequency:
+                break
+            
+            # Merge pair
+            new_token = best_pair[0] + best_pair[1]
+            
+            # Check length constraint
+            if max_token_length and len(new_token) > max_token_length:
+                # remove this pair from consideration for this iteration and future?
+                # Actually, skipping it here is tricky because we need to ignore it in pair_counts next time
+                # Simpler: Just skip adding it to merges and modify word_freqs?
+                # No, if we don't merge, we just continue to the next best pair in THIS iteration.
+                # But pair_counts is already computed.
+                # We need to loop until we find a valid pair or run out
+                
+                # In this simple implementation, let's just skip this merge efficiently
+                # We need to find the NEXT most common pair.
+                
+                # Re-do finding best pair loop
+                found_valid_pair = False
+                for pair, count in pair_counts.most_common():
+                    token_candidate = pair[0] + pair[1]
+                    if max_token_length and len(token_candidate) > max_token_length:
+                        continue # Skip too long
+                    
+                    if count < min_frequency:
+                        break # Stop if frequency too low
+                        
+                    # Found valid pair
+                    best_pair = pair
+                    best_count = count
+                    new_token = token_candidate
+                    found_valid_pair = True
+                    break
+                
+                if not found_valid_pair:
+                    print(f"  Stopping early: No more pairs satisfy max_token_length={max_token_length}")
+                    break
+            
+            # Final check before merging (in case we didn't enter the if block but updated vars)
+            # Actually the logic above handles it. If we entered the block, we either found a new best_pair or broke.
+            
+            merges.append(best_pair)
+            
+            # Add to vocab
+            tokenizer.token_to_id[new_token] = vocab_id
+            tokenizer.id_to_token[vocab_id] = new_token
+            vocab_id += 1
+            
+            # Update word_freqs
+            new_word_freqs = {}
+            for word, freq in word_freqs.items():
+                new_word = []
+                i = 0
+                while i < len(word):
+                    if i < len(word) - 1 and word[i] == best_pair[0] and word[i + 1] == best_pair[1]:
+                        new_word.append(new_token)
+                        i += 2
+                    else:
+                        new_word.append(word[i])
+                        i += 1
+                new_word_freqs[tuple(new_word)] = freq
+            word_freqs = new_word_freqs
+            
+            if (merge_idx + 1) % 100 == 0:
+                print(f"  Merge {merge_idx + 1}/{num_merges}: '{best_pair[0]}' + '{best_pair[1]}' -> '{new_token}' (count={best_count})")
+        
+        tokenizer.merges = merges
+        print(f"Final vocab size: {len(tokenizer.token_to_id)}")
+        
+        # Save if requested
+        if output_path:
+            tokenizer.save_vocab(output_path)
+        
+        return tokenizer
+    
+    def apply_bpe(self, text: str) -> List[str]:
+        """Apply BPE merges to a text string."""
+        if text in self.token_to_id:
+            return [text]
+        
+        # Split into characters
+        tokens = list(text)
+        
+        # Apply merges
+        for pair in self.merges:
+            new_tokens = []
+            i = 0
+            while i < len(tokens):
+                if i < len(tokens) - 1 and tokens[i] == pair[0] and tokens[i + 1] == pair[1]:
+                    new_tokens.append(pair[0] + pair[1])
+                    i += 2
+                else:
+                    new_tokens.append(tokens[i])
+                    i += 1
+            tokens = new_tokens
+        
+        return tokens
+    
+    def tokenize(self, wurcs: str, max_length: int = 256) -> Dict:
+        """
+        Tokenize a WURCS string.
+        
+        Returns:
+            Dict with:
+                - tokens: List of token strings
+                - token_ids: List of token IDs
+                - residue_ids: List of residue IDs
+                - branch_depths: List of branch depths
+                - linkage_types: List of linkage types
+                - attention_mask: Attention mask
+        """
+        # Pre-tokenize
+        units = self.pre_tokenizer.pre_tokenize(wurcs)
+        
+        tokens = []
+        token_ids = []
+        residue_ids = []
+        branch_depths = []
+        linkage_types = []
+        
+        for unit in units:
+            if unit['type'] == 'special':
+                # Special tokens stay as-is
+                tok = unit['text']
+                tokens.append(tok)
+                token_ids.append(self.token_to_id.get(tok, self.token_to_id['[UNK]']))
+                residue_ids.append(unit['residue_id'])
+                branch_depths.append(unit['branch_depth'])
+                linkage_types.append(unit['linkage_type'])
+            else:
+                # Apply BPE to this unit
+                bpe_tokens = self.apply_bpe(unit['text'])
+                for tok in bpe_tokens:
+                    tokens.append(tok)
+                    token_ids.append(self.token_to_id.get(tok, self.token_to_id['[UNK]']))
+                    residue_ids.append(unit['residue_id'])
+                    branch_depths.append(unit['branch_depth'])
+                    linkage_types.append(unit['linkage_type'])
+        
+        # Truncate if needed
+        if len(tokens) > max_length:
+            tokens = tokens[:max_length - 1] + ['[END]']
+            token_ids = token_ids[:max_length - 1] + [self.token_to_id['[END]']]
+            residue_ids = residue_ids[:max_length - 1] + [-1]
+            branch_depths = branch_depths[:max_length - 1] + [0]
+            linkage_types = linkage_types[:max_length - 1] + [0]
+        
+        # Create attention mask and pad
+        length = len(tokens)
+        attention_mask = [1] * length
+        
+        while len(tokens) < max_length:
+            tokens.append('[PAD]')
+            token_ids.append(self.token_to_id['[PAD]'])
+            residue_ids.append(-1)
+            branch_depths.append(0)
+            linkage_types.append(0)
+            attention_mask.append(0)
+        # Pre-tokenize
+        units = self.pre_tokenizer.pre_tokenize(wurcs)
+        
+        # Extract distance matrix from pre-tokenizer result
+        dist_matrix_raw = units[0].get('distance_matrix', [])
+        num_residues = len(dist_matrix_raw)
+        
+        # Map token-to-token distances using residue_ids
+        # token_i is associated with residue_ids[i]. 
+        # residue_ids[i] is index into dist_matrix_raw.
+        # If residue_ids[i] == -1 (special), distance is undefined (use -1 or 999)
+        
+        # Use UNPADDED length for distance matrix to save massive memory
+        # distance_matrix will be e.g. 20x20, while tokens are padded to 256
+        token_len = length 
+        distance_matrix = [[-1] * token_len for _ in range(token_len)]
+        
+        for i in range(token_len):
+            for j in range(token_len):
+                r_i = residue_ids[i]
+                r_j = residue_ids[j]
+                
+                if r_i >= 0 and r_j >= 0 and r_i < num_residues and r_j < num_residues:
+                    distance_matrix[i][j] = dist_matrix_raw[r_i][r_j]
+                else:
+                    distance_matrix[i][j] = -1 # Special/Padding
+                    
+        # MEMORY OPTIMIZATION: Do NOT pad matrix here. 
+        # Pad on-the-fly in Dataset class instead.
+        # This saves massive memory (0.2GB vs 66GB).
+        
+        return {
+            'tokens': tokens,
+            'token_ids': token_ids,
+            'residue_ids': residue_ids,
+            'branch_depths': branch_depths,
+            'linkage_types': linkage_types,
+            'attention_mask': attention_mask,
+            'distance_matrix': distance_matrix, # New Output
+            'length': length,
+        }
+    
+    def save_vocab(self, path: str):
+        """Save vocabulary to JSON file."""
+        data = {
+            'special_tokens': self.special_tokens,
+            'token_to_id': self.token_to_id,
+            'merges': [list(m) for m in self.merges],
+            'metadata': {
+                'vocab_size': len(self.token_to_id),
+                'num_merges': len(self.merges),
+            }
+        }
+        with open(path, 'w') as f:
+            json.dump(data, f, indent=2)
+        print(f"Saved vocabulary to {path}")
+    
+    def load_vocab(self, path: str):
+        """Load vocabulary from JSON file."""
+        with open(path, 'r') as f:
+            data = json.load(f)
+        
+        self.special_tokens = data['special_tokens']
+        self.token_to_id = data['token_to_id']
+        self.id_to_token = {int(v): k for k, v in self.token_to_id.items()}
+        self.merges = [tuple(m) for m in data['merges']]
+        
+        print(f"Loaded vocabulary with {len(self.token_to_id)} tokens")
+    
+    @property
+    def vocab_size(self) -> int:
+        return len(self.token_to_id)
+
+
+# ============================================================================
+# Testing
+# ============================================================================
+
+if __name__ == '__main__':
+    # Test pre-tokenizer
+    print("="*80)
+    print("Testing WURCSPreTokenizer")
+    print("="*80)
+    
+    pre_tok = WURCSPreTokenizer()
+    
+    test_wurcs = [
+        "WURCS=2.0/2,2,1/[a2122h-1b_1-5][a2211m-1a_1-5]/1-2/a4-b1",
+        "WURCS=2.0/3,3,2/[a2122h-1b_1-5_2*NCC/3=O][a2112h-1a_1-5][a2211m-1a_1-5]/1-2-3/a4-b1_b3-c1",
+    ]
+    
+    for wurcs in test_wurcs:
+        print(f"\nWURCS: {wurcs[:60]}...")
+        units = pre_tok.pre_tokenize(wurcs)
+        print(f"Units ({len(units)}):")
+        for u in units[:10]:
+            print(f"  {u['type']:10} | res={u['residue_id']:2} | depth={u['branch_depth']} | {u['text']}")
+        if len(units) > 10:
+            print(f"  ... and {len(units) - 10} more")

releases/2026-10-02/iar_completion/runtime_snapshot/project/data/bpe_ambiguity_tokens.json

@@ -0,0 +1,721 @@
+{
+  "ambiguous_tokens": {
+    "?": 32,
+    "?|": 90,
+    "a?|": 108,
+    "a?|b": 109,
+    "?|c": 110,
+    "a?|b?|c": 111,
+    "?|d": 112,
+    "a?|b?|c?|d": 113,
+    "?|e": 114,
+    "a?|b?|c?|d?|e": 115,
+    "?|f": 116,
+    "a?|b?|c?|d?|e?|f": 117,
+    "?-": 118,
+    "?|g": 119,
+    "a?|b?|c?|d?|e?|f?|g": 120,
+    "?|h": 122,
+    "?|i": 123,
+    "?|h?|i": 124,
+    "?|j": 125,
+    "?|h?|i?|j": 126,
+    "?|k": 128,
+    "?|h?|i?|j?|k": 129,
+    "?|l": 130,
+    "?|h?|i?|j?|k?|l": 131,
+    "?|m": 132,
+    "?|h?|i?|j?|k?|l?|m": 133,
+    "?|h?|i?|j?|k?|l?|m?|": 138,
+    "n?|": 141,
+    "n?|o": 142,
+    "?}": 143,
+    "n?|o?|": 146,
+    "n?|o?|p": 147,
+    "?}-": 149,
+    "?}-{": 150,
+    "n?|o?|p?|": 153,
+    "n?|o?|p?|q": 154,
+    "n?|o?|p?|q?|": 157,
+    "n?|o?|p?|q?|r": 158,
+    "n?|o?|p?|q?|r?|": 165,
+    "n?|o?|p?|q?|r?|s": 166,
+    "n?|o?|p?|q?|r?|s?|": 170,
+    "n?|o?|p?|q?|r?|s?|t": 171,
+    "?|u": 189,
+    "a?-": 197,
+    "c?-": 201,
+    "?|u?|": 209,
+    "?|u?|v": 210,
+    "b?-": 211,
+    "a?-b1": 213,
+    "d?-": 217,
+    "b?-c1": 221,
+    "c?-d1": 230,
+    "?|u?|v?|": 231,
+    "?|u?|v?|w": 232,
+    "1-?": 242,
+    "d?-e1": 244,
+    "e?-": 245,
+    "e?-f1": 262,
+    "?|u?|v?|w?|": 266,
+    "?|u?|v?|w?|x": 267,
+    "f?-": 273,
+    "?|u?|v?|w?|x?|": 288,
+    "?|u?|v?|w?|x?|y": 289,
+    "g?-": 298,
+    "n?|o?|p?|q?|r?|s?|t?": 304,
+    "i?-": 306,
+    "h?-": 308,
+    "?|u?}-{": 312,
+    "?|u?": 313,
+    "n?|o?|p?|q?|r?}-{": 314,
+    "n?|o?|p?|q?|r?": 315,
+    "f?-g1": 318,
+    "n?|o?}-{": 322,
+    "n?|o?": 323,
+    "?|u?|v?|w?|x?|y?|": 325,
+    "?|u?|v?|w?|x?|y?|z": 326,
+    "n?|o?|p?|q?|r?|s?}-{": 328,
+    "n?|o?|p?|q?|r?|s?": 329,
+    "n?|o?|p?}-{": 331,
+    "n?|o?|p?": 332,
+    "n?|o?|p?|q?}-{": 336,
+    "n?|o?|p?|q?": 337,
+    "g?-h1": 339,
+    "?|h?|i?|j?|k?|l?}-{": 342,
+    "?|h?|i?|j?|k?|l?": 343,
+    "n?}-{": 344,
+    "n?": 345,
+    "j?-": 346,
+    "h?-i1": 347,
+    "?|u?|v?}-{": 351,
+    "?|u?|v?": 352,
+    "k?-": 353,
+    "i?-j1": 355,
+    "?|h?|i?|j?|k?|l?|m?": 363,
+    "?|h?|i?|j?|k?}-{": 364,
+    "?|h?|i?|j?|k?": 365,
+    "?|u?|v?|w?|x?|y?|z?|": 369,
+    "?|h?|i?|j?}-{": 375,
+    "?|h?|i?|j?": 376,
+    "l?-": 377,
+    "A?|": 392,
+    "A?|B": 393,
+    "j?-k1": 401,
+    "m?-": 404,
+    "?|h?|i?}-{": 408,
+    "?|h?|i?": 409,
+    "k?-l1": 418,
+    "?|h?}-{": 420,
+    "?|h?": 421,
+    "A?|B?|": 424,
+    "A?|B?|C": 425,
+    "a?|b?|c?|d?|e?|f?|g?": 427,
+    "f?-g2": 431,
+    "a?|b?|c?|d?|e?|f?}-{": 437,
+    "a?|b?|c?|d?|e?|f?": 438,
+    "l?-m1": 442,
+    "?|u?|v?|w?}-{": 450,
+    "?|u?|v?|w?": 451,
+    "A?|B?|C?|": 464,
+    "A?|B?|C?|D": 465,
+    "a?|b?|c?|d?|e?}-{": 475,
+    "a?|b?|c?|d?|e?": 476,
+    "n?-": 499,
+    "a?|b?|c?|d?}-{": 502,
+    "a?|b?|c?|d?": 503,
+    "m?-n1": 518,
+    "A?|B?|C?|D?|": 521,
+    "A?|B?|C?|D?|E": 522,
+    "o?-": 534,
+    "d?-h1": 536,
+    "A?|B?|C?|D?|E?|": 542,
+    "A?|B?|C?|D?|E?|F": 543,
+    "c?-i1": 544,
+    "c?-h1": 549,
+    "A?|B?|C?|D?|E?|F?|": 550,
+    "A?|B?|C?|D?|E?|F?|G": 551,
+    "?|u?|v?|w?|x?}-{": 563,
+    "?|u?|v?|w?|x?": 564,
+    "a?|b?|c?}-{": 571,
+    "a?|b?|c?}-{a?|b?|c": 572,
+    "a?|b?|c?}-{a?|b?|c?": 573,
+    "?|H": 581,
+    "2-?": 592,
+    "?|H?|": 598,
+    "?|H?|I": 599,
+    "?}*OC": 600,
+    "c?-k1": 607,
+    "c?-g1": 609,
+    "?|H?|I?|": 615,
+    "?|H?|I?|J": 616,
+    "n?-o1": 617,
+    "d?-g1": 629,
+    "o?-p1": 634,
+    "p?-": 646,
+    "?|u?|v?|w?|x?|y?}-{": 653,
+    "?|u?|v?|w?|x?|y?": 654,
+    "b?-c2": 656,
+    "d?-i1": 658,
+    "c?-j1": 691,
+    "?}*OSO": 696,
+    "e?-h1": 701,
+    "q?-": 713,
+    "c?-f1": 720,
+    "i?-j2": 728,
+    "?|h?|i?}": 742,
+    "h?-i2": 747,
+    "g?-h2": 753,
+    "c?-l1": 756,
+    "j?-k2": 758,
+    "?|h?}": 759,
+    "c?-e1": 760,
+    "?|H?|I?|J?|": 761,
+    "?|H?|I?|J?|K": 762,
+    "a?|b?|c?|d?|e?|f?}": 772,
+    "b?-e1": 774,
+    "b?-f1": 791,
+    "d?-f1": 794,
+    "p?-q1": 796,
+    "a?|b?|c?|d?|e?}": 798,
+    "a?-d1": 800,
+    "m?-n2": 803,
+    "e?-g1": 809,
+    "?|h?|i?|j?}": 812,
+    "r?-": 817,
+    "a?-c1": 818,
+    "?|u?|v?|w?|x?|y?|z?": 822,
+    "a?-e1": 826,
+    "d?-j1": 833,
+    "b?-g1": 834,
+    "q?-r1": 847,
+    "d?-e2": 854,
+    "c?-m1": 860,
+    "a?-f1": 875,
+    "b?-d1": 887,
+    "?|H?|I?|J?|K?|": 892,
+    "?|H?|I?|J?|K?|L": 893,
+    "?|H?|I?|J?|K?|L?|": 894,
+    "?|H?|I?|J?|K?|L?|M": 895,
+    "?|H?|I?|J?|K?|L?|M?|": 896,
+    "a?-l1": 920,
+    "?*OSO/3=O/3=O": 923,
+    "k?-l2": 940,
+    "k?-o1": 942,
+    "N?|": 965,
+    "N?|O": 966,
+    "N?|O?|": 967,
+    "N?|O?|P": 968,
+    "N?|O?|P?|": 969,
+    "N?|O?|P?|Q": 970,
+    "N?|O?|P?|Q?|": 971,
+    "N?|O?|P?|Q?|R": 972,
+    "N?|O?|P?|Q?|R?|": 973,
+    "N?|O?|P?|Q?|R?|S": 974,
+    "N?|O?|P?|Q?|R?|S?|": 975,
+    "N?|O?|P?|Q?|R?|S?|T": 976,
+    "?|U": 977,
+    "?|U?|": 978,
+    "?|U?|V": 979,
+    "c?-d2": 983,
+    "r?-s1": 988,
+    "a?|b?}-{": 995,
+    "a?|b?}-{a?|b": 996,
+    "a?|b?}-{a?|b?": 997,
+    "e?-f2": 1001,
+    "g?-i1": 1006,
+    "i?-l1": 1010,
+    "s?-": 1011,
+    "?|h?|i?|j?|k?}": 1017,
+    "b?-h1": 1034,
+    "a?-j1": 1038,
+    "n?-o2": 1046,
+    "a?-b2": 1069,
+    "e?-i1": 1095,
+    "h?-j1": 1102,
+    "a?-k1": 1108,
+    "i?-k1": 1115,
+    "a?-g1": 1116,
+    "?}*OPO": 1122,
+    "d?-k1": 1129,
+    "a?-m1": 1151,
+    "a?-i1": 1159,
+    "A?}-{": 1174,
+    "A?": 1175,
+    "?}*OCC": 1177,
+    "l?-m2": 1179,
+    "A?|B?}-{": 1180,
+    "A?|B?": 1181,
+    "f?-h1": 1183,
+    "a?-n1": 1189,
+    "p?-q2": 1192,
+    "c?-n1": 1197,
+    "?|U?|V?|": 1202,
+    "?|U?|V?|W": 1203,
+    "?|U?|V?|W?|": 1204,
+    "?|U?|V?|W?|X": 1205,
+    "?|U?|V?|W?|X?|": 1206,
+    "?|U?|V?|W?|X?|Y": 1207,
+    "?|a": 1208,
+    "s?-t1": 1223,
+    "?|h?|i?|j?|k?|l?|m?}": 1228,
+    "g?-j1": 1234,
+    "A?|B?|C?|D?}-{": 1242,
+    "A?|B?|C?|D?": 1243,
+    "a?-h1": 1253,
+    "?|H?|I?|J?}-{": 1257,
+    "?|H?|I?|J?": 1258,
+    "o?-p2": 1261,
+    "b?-i1": 1273,
+    "?|h?|i?|j?|k?|l?}": 1309,
+    "j?-m1": 1317,
+    "c?-o1": 1318,
+    "a?-o1": 1330,
+    "a?|b?|c?}*OC": 1331,
+    "b?-j1": 1357,
+    "a?-r1": 1361,
+    "n?}": 1363,
+    "A?|B?|C?}-{": 1371,
+    "A?|B?|C?": 1372,
+    "m?-p1": 1375,
+    "l?-p1": 1383,
+    "a?-p1": 1444,
+    "k?-n1": 1446,
+    "j?-l1": 1470,
+    "?|U?|V?|W?|X?|Y?|": 1471,
+    "?|U?|V?|W?|X?|Y?|Z": 1472,
+    "?|aa?|": 1473,
+    "?|aa?|a": 1474,
+    "?|aa?|ab": 1475,
+    "?*OPO/3O/3=O": 1476,
+    "l?-q1": 1489,
+    "l?-n1": 1499,
+    "a?-s1": 1517,
+    "k?-m1": 1524,
+    "a?-q1": 1546,
+    "c?-q1": 1547,
+    "t?-": 1551,
+    "a?|b?|c?|d?}*OC": 1565,
+    "f?-i1": 1590,
+    "c?-p1": 1591,
+    "n?-q1": 1593,
+    "?|i?}": 1611,
+    "a?|b?|c?|d?|e?}*OC": 1612,
+    "m?-q1": 1617,
+    "q?-r2": 1623,
+    "l?-o1": 1624,
+    "m?-r1": 1628,
+    "a?-t1": 1630,
+    "a?|b?|c?|d?}*OSO": 1649,
+    "c?-r1": 1675,
+    "1-d?|i?}": 1683,
+    "j?-n1": 1691,
+    "u?-": 1694,
+    "a?|b?|c?|d?|e?}*OSO": 1718,
+    "?*OCC/3=O": 1723,
+    "?%": 1752,
+    "?*OP^XOCCN/3O/3=O": 1770,
+    "t?-u1": 1772,
+    "?*": 1774,
+    "c?-s1": 1775,
+    "a?-u1": 1793,
+    "f?-h2": 1808,
+    "e?-j1": 1811,
+    "c?-t1": 1818,
+    "f1-a?|b?|c?|d?|e?}": 1822,
+    "u?-v1": 1835,
+    "h?-k1": 1841,
+    "?|H?|I?|J?|K?}-{": 1846,
+    "?|H?|I?|J?|K?": 1847,
+    "n?|o?}": 1851,
+    "1-d?|h?}": 1852,
+    "q?-s1": 1872,
+    "%?%": 1880,
+    "b?-g2": 1881,
+    "r?-s2": 1882,
+    "d?-l1": 1898,
+    "v?-": 1917,
+    "b?-k1": 1927,
+    "?|aa?|ab?|a": 1942,
+    "?|aa?|ab?|ac": 1943,
+    "?|aa?|ab?|ac?|": 1944,
+    "?|aa?|ab?|ac?|ad": 1945,
+    "a?|b?}*OC": 1949,
+    "?*OC": 1952,
+    "e?-k1": 1955,
+    "a?-d2": 1999,
+    "s?-t2": 2013,
+    "a?-f2": 2027,
+    "o?-q1": 2030,
+    "?}*OP^XOCCN": 2040,
+    "a?|b?|c?}*OCC": 2047,
+    "m?-o1": 2048,
+    "c?-f2": 2058,
+    "A?|B?|C?|D?|E?|F?|G?": 2060,
+    "a?|b?|c?}*OSO": 2071,
+    "?|U?|V?}-{": 2079,
+    "?|U?|V?": 2080,
+    "c?-u1": 2087
+  },
+  "ambiguous_ids": [
+    32,
+    90,
+    108,
+    109,
+    110,
+    111,
+    112,
+    113,
+    114,
+    115,
+    116,
+    117,
+    118,
+    119,
+    120,
+    122,
+    123,
+    124,
+    125,
+    126,
+    128,
+    129,
+    130,
+    131,
+    132,
+    133,
+    138,
+    141,
+    142,
+    143,
+    146,
+    147,
+    149,
+    150,
+    153,
+    154,
+    157,
+    158,
+    165,
+    166,
+    170,
+    171,
+    189,
+    197,
+    201,
+    209,
+    210,
+    211,
+    213,
+    217,
+    221,
+    230,
+    231,
+    232,
+    242,
+    244,
+    245,
+    262,
+    266,
+    267,
+    273,
+    288,
+    289,
+    298,
+    304,
+    306,
+    308,
+    312,
+    313,
+    314,
+    315,
+    318,
+    322,
+    323,
+    325,
+    326,
+    328,
+    329,
+    331,
+    332,
+    336,
+    337,
+    339,
+    342,
+    343,
+    344,
+    345,
+    346,
+    347,
+    351,
+    352,
+    353,
+    355,
+    363,
+    364,
+    365,
+    369,
+    375,
+    376,
+    377,
+    392,
+    393,
+    401,
+    404,
+    408,
+    409,
+    418,
+    420,
+    421,
+    424,
+    425,
+    427,
+    431,
+    437,
+    438,
+    442,
+    450,
+    451,
+    464,
+    465,
+    475,
+    476,
+    499,
+    502,
+    503,
+    518,
+    521,
+    522,
+    534,
+    536,
+    542,
+    543,
+    544,
+    549,
+    550,
+    551,
+    563,
+    564,
+    571,
+    572,
+    573,
+    581,
+    592,
+    598,
+    599,
+    600,
+    607,
+    609,
+    615,
+    616,
+    617,
+    629,
+    634,
+    646,
+    653,
+    654,
+    656,
+    658,
+    691,
+    696,
+    701,
+    713,
+    720,
+    728,
+    742,
+    747,
+    753,
+    756,
+    758,
+    759,
+    760,
+    761,
+    762,
+    772,
+    774,
+    791,
+    794,
+    796,
+    798,
+    800,
+    803,
+    809,
+    812,
+    817,
+    818,
+    822,
+    826,
+    833,
+    834,
+    847,
+    854,
+    860,
+    875,
+    887,
+    892,
+    893,
+    894,
+    895,
+    896,
+    920,
+    923,
+    940,
+    942,
+    965,
+    966,
+    967,
+    968,
+    969,
+    970,
+    971,
+    972,
+    973,
+    974,
+    975,
+    976,
+    977,
+    978,
+    979,
+    983,
+    988,
+    995,
+    996,
+    997,
+    1001,
+    1006,
+    1010,
+    1011,
+    1017,
+    1034,
+    1038,
+    1046,
+    1069,
+    1095,
+    1102,
+    1108,
+    1115,
+    1116,
+    1122,
+    1129,
+    1151,
+    1159,
+    1174,
+    1175,
+    1177,
+    1179,
+    1180,
+    1181,
+    1183,
+    1189,
+    1192,
+    1197,
+    1202,
+    1203,
+    1204,
+    1205,
+    1206,
+    1207,
+    1208,
+    1223,
+    1228,
+    1234,
+    1242,
+    1243,
+    1253,
+    1257,
+    1258,
+    1261,
+    1273,
+    1309,
+    1317,
+    1318,
+    1330,
+    1331,
+    1357,
+    1361,
+    1363,
+    1371,
+    1372,
+    1375,
+    1383,
+    1444,
+    1446,
+    1470,
+    1471,
+    1472,
+    1473,
+    1474,
+    1475,
+    1476,
+    1489,
+    1499,
+    1517,
+    1524,
+    1546,
+    1547,
+    1551,
+    1565,
+    1590,
+    1591,
+    1593,
+    1611,
+    1612,
+    1617,
+    1623,
+    1624,
+    1628,
+    1630,
+    1649,
+    1675,
+    1683,
+    1691,
+    1694,
+    1718,
+    1723,
+    1752,
+    1770,
+    1772,
+    1774,
+    1775,
+    1793,
+    1808,
+    1811,
+    1818,
+    1822,
+    1835,
+    1841,
+    1846,
+    1847,
+    1851,
+    1852,
+    1872,
+    1880,
+    1881,
+    1882,
+    1898,
+    1917,
+    1927,
+    1942,
+    1943,
+    1944,
+    1945,
+    1949,
+    1952,
+    1955,
+    1999,
+    2013,
+    2027,
+    2030,
+    2040,
+    2047,
+    2048,
+    2058,
+    2060,
+    2071,
+    2079,
+    2080,
+    2087
+  ],
+  "source_vocab": "data/bpe_vocabulary_clean.json"
+}

releases/2026-10-02/iar_completion/runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_ambiguity_tokens.json

@@ -0,0 +1,764 @@
+{
+  "ambiguous_ids": [
+    39,
+    114,
+    131,
+    132,
+    133,
+    134,
+    135,
+    136,
+    137,
+    138,
+    140,
+    141,
+    142,
+    143,
+    144,
+    145,
+    147,
+    148,
+    149,
+    150,
+    151,
+    152,
+    153,
+    155,
+    156,
+    157,
+    158,
+    163,
+    164,
+    165,
+    167,
+    168,
+    170,
+    175,
+    176,
+    180,
+    181,
+    183,
+    184,
+    192,
+    193,
+    197,
+    198,
+    217,
+    218,
+    226,
+    229,
+    237,
+    238,
+    239,
+    241,
+    247,
+    251,
+    258,
+    264,
+    265,
+    273,
+    275,
+    276,
+    295,
+    298,
+    299,
+    309,
+    322,
+    323,
+    329,
+    334,
+    335,
+    336,
+    340,
+    341,
+    342,
+    345,
+    349,
+    350,
+    351,
+    352,
+    353,
+    354,
+    355,
+    359,
+    360,
+    361,
+    363,
+    364,
+    365,
+    366,
+    367,
+    368,
+    369,
+    371,
+    372,
+    373,
+    375,
+    376,
+    377,
+    378,
+    379,
+    380,
+    383,
+    384,
+    385,
+    387,
+    388,
+    389,
+    390,
+    391,
+    401,
+    405,
+    409,
+    415,
+    416,
+    419,
+    420,
+    421,
+    426,
+    427,
+    428,
+    430,
+    431,
+    432,
+    434,
+    435,
+    440,
+    441,
+    442,
+    444,
+    445,
+    446,
+    450,
+    462,
+    463,
+    470,
+    476,
+    477,
+    478,
+    481,
+    487,
+    488,
+    489,
+    493,
+    494,
+    496,
+    499,
+    516,
+    535,
+    536,
+    538,
+    539,
+    540,
+    552,
+    590,
+    592,
+    602,
+    603,
+    604,
+    608,
+    609,
+    620,
+    635,
+    636,
+    637,
+    640,
+    646,
+    647,
+    649,
+    654,
+    659,
+    660,
+    661,
+    667,
+    668,
+    675,
+    676,
+    688,
+    690,
+    711,
+    716,
+    720,
+    721,
+    734,
+    742,
+    752,
+    754,
+    778,
+    788,
+    791,
+    793,
+    808,
+    809,
+    810,
+    817,
+    820,
+    831,
+    833,
+    834,
+    843,
+    844,
+    859,
+    869,
+    870,
+    873,
+    880,
+    885,
+    886,
+    893,
+    894,
+    910,
+    928,
+    938,
+    939,
+    940,
+    941,
+    942,
+    943,
+    944,
+    950,
+    952,
+    953,
+    958,
+    959,
+    961,
+    963,
+    972,
+    979,
+    987,
+    988,
+    989,
+    994,
+    995,
+    996,
+    1000,
+    1001,
+    1003,
+    1004,
+    1005,
+    1006,
+    1007,
+    1008,
+    1009,
+    1010,
+    1011,
+    1012,
+    1013,
+    1014,
+    1015,
+    1016,
+    1017,
+    1019,
+    1021,
+    1026,
+    1038,
+    1050,
+    1055,
+    1072,
+    1078,
+    1115,
+    1116,
+    1124,
+    1138,
+    1150,
+    1161,
+    1167,
+    1168,
+    1169,
+    1170,
+    1171,
+    1172,
+    1173,
+    1178,
+    1193,
+    1197,
+    1220,
+    1233,
+    1250,
+    1253,
+    1262,
+    1267,
+    1301,
+    1305,
+    1317,
+    1318,
+    1333,
+    1342,
+    1349,
+    1360,
+    1370,
+    1371,
+    1372,
+    1373,
+    1374,
+    1383,
+    1389,
+    1390,
+    1391,
+    1396,
+    1416,
+    1420,
+    1425,
+    1428,
+    1433,
+    1445,
+    1478,
+    1483,
+    1499,
+    1500,
+    1501,
+    1503,
+    1513,
+    1524,
+    1531,
+    1561,
+    1563,
+    1566,
+    1567,
+    1568,
+    1600,
+    1601,
+    1602,
+    1605,
+    1608,
+    1626,
+    1634,
+    1635,
+    1636,
+    1661,
+    1669,
+    1671,
+    1672,
+    1686,
+    1726,
+    1737,
+    1738,
+    1739,
+    1740,
+    1741,
+    1752,
+    1763,
+    1773,
+    1780,
+    1790,
+    1796,
+    1798,
+    1804,
+    1829,
+    1842,
+    1888,
+    1893,
+    1905,
+    1907,
+    1912,
+    1918,
+    1923,
+    1940,
+    1945,
+    1948,
+    1951,
+    1961,
+    1991,
+    1992,
+    1993,
+    2016,
+    2020,
+    2021,
+    2030,
+    2033,
+    2034,
+    2035,
+    2064,
+    2066,
+    2067,
+    2077,
+    2093,
+    2100,
+    2101,
+    2105,
+    2110
+  ],
+  "ambiguous_tokens": {
+    "%?%": 1763,
+    "-?": 1918,
+    "1-?": 273,
+    "1-a?|b?|c?|d?|e?|f?}": 928,
+    "1-a?|b?|c?|d?|e?}": 869,
+    "1-d?|i?}": 2100,
+    "2-?": 721,
+    "<Q>-?": 2016,
+    "?": 39,
+    "?%": 1669,
+    "?*OCC/3=O": 2033,
+    "?*OPO/3O/3=O": 1796,
+    "?*OSO/3=O/3=O": 1078,
+    "?-": 149,
+    "?-?": 2067,
+    "?|": 114,
+    "?|A": 434,
+    "?|B": 462,
+    "?|C": 493,
+    "?|D": 535,
+    "?|E": 608,
+    "?|F": 635,
+    "?|G": 646,
+    "?|H": 667,
+    "?|I": 675,
+    "?|J": 688,
+    "?|K": 831,
+    "?|L": 939,
+    "?|L?|M": 942,
+    "?|L?|M?|N": 943,
+    "?|M": 940,
+    "?|N": 941,
+    "?|O": 1003,
+    "?|O?|P": 1011,
+    "?|O?|P?|Q": 1012,
+    "?|O?|P?|Q?|R": 1013,
+    "?|O?|P?|Q?|R?|S": 1014,
+    "?|O?|P?|Q?|R?|S?|T": 1015,
+    "?|O?|P?|Q?|R?|S?|T?|U": 1016,
+    "?|O?|P?|Q?|R?|S?|T?|U?|V": 1017,
+    "?|P": 1004,
+    "?|Q": 1005,
+    "?|R": 1006,
+    "?|S": 1007,
+    "?|T": 1008,
+    "?|U": 1009,
+    "?|V": 1010,
+    "?|W": 1167,
+    "?|W?|X": 1170,
+    "?|W?|X?|Y": 1171,
+    "?|X": 1168,
+    "?|Y": 1169,
+    "?|Z": 1370,
+    "?|Z?|a": 1371,
+    "?|Z?|aa?|": 1372,
+    "?|Z?|aa?|ab": 1373,
+    "?|a": 552,
+    "?|ac": 1738,
+    "?|ac?|ad": 1739,
+    "?|ad": 1737,
+    "?|c": 133,
+    "?|d": 135,
+    "?|e": 137,
+    "?|f": 140,
+    "?|g": 142,
+    "?|h": 144,
+    "?|h?}": 2064,
+    "?|i": 147,
+    "?|i?}": 1842,
+    "?|j": 150,
+    "?|k": 152,
+    "?|l": 155,
+    "?|m": 157,
+    "?|n": 164,
+    "?|o": 167,
+    "?|p": 175,
+    "?|s": 192,
+    "?|t": 197,
+    "?|u": 217,
+    "?|v": 238,
+    "?|w": 264,
+    "?|x": 298,
+    "?|y": 322,
+    "?|z": 387,
+    "?}": 163,
+    "?}*OC": 716,
+    "?}*OCC/3=O": 870,
+    "?}*OPO/3O/3=O": 742,
+    "?}*OSO/3=O/3=O": 592,
+    "?}-{": 170,
+    "?}-{a?|b": 994,
+    "?}-{a?|b?": 995,
+    "?}-{a?|b?|c": 602,
+    "?}-{a?|b?|c?": 603,
+    "?}-{a?|b?|c?|d": 487,
+    "?}-{a?|b?|c?|d?": 488,
+    "?}-{a?|b?|c?|d?|e": 476,
+    "?}-{a?|b?|c?|d?|e?": 477,
+    "?}-{a?|b?|c?|d?|e?|f": 440,
+    "?}-{a?|b?|c?|d?|e?|f?": 441,
+    "?}-{a?|b?|c?|d?|e?|f?|g": 444,
+    "?}-{a?|b?|c?|d?|e?|f?|g?": 445,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h": 430,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?": 431,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i": 419,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?": 420,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j": 383,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?": 384,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k": 371,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?": 372,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l": 340,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?": 341,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m": 389,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?": 390,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n": 378,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?": 379,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o": 359,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?": 360,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p": 349,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?": 350,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q": 375,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?": 376,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r": 353,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?": 354,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s": 367,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?": 368,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t": 334,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?": 335,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u": 364,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?": 365,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v": 426,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?": 427,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w": 538,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?": 539,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x": 659,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?": 660,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y": 808,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?": 809,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z": 987,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?": 988,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A": 1499,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?": 1500,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B": 1389,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?": 1390,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C": 1634,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?": 1635,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D": 1600,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?": 1601,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J": 1566,
+    "?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J?": 1567,
+    "a?-": 226,
+    "a?-b1": 241,
+    "a?-b2": 1267,
+    "a?-c1": 972,
+    "a?-d1": 959,
+    "a?-e1": 979,
+    "a?-f1": 1055,
+    "a?-g1": 1342,
+    "a?-h1": 1561,
+    "a?-i1": 1420,
+    "a?-j1": 1233,
+    "a?-k1": 1318,
+    "a?-l1": 1115,
+    "a?-m1": 1416,
+    "a?-n1": 1425,
+    "a?-o1": 1605,
+    "a?-p1": 1740,
+    "a?-q1": 1912,
+    "a?-r1": 1661,
+    "a?-s1": 1907,
+    "a?-t1": 2020,
+    "a?|": 131,
+    "a?|b": 132,
+    "a?|b?|c": 134,
+    "a?|b?|c?|d": 136,
+    "a?|b?|c?|d?|e": 138,
+    "a?|b?|c?|d?|e?|f": 141,
+    "a?|b?|c?|d?|e?|f?|g": 143,
+    "a?|b?|c?|d?|e?|f?|g?|h": 145,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i": 148,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j": 151,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k": 153,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l": 156,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m": 158,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n": 165,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o": 168,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p": 176,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|": 180,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q": 181,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|": 183,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r": 184,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s": 193,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t": 198,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u": 218,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v": 239,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w": 265,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x": 299,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y": 323,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z": 388,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A": 435,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B": 463,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C": 494,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D": 536,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E": 609,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F": 636,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G": 647,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H": 668,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I": 676,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J": 690,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J?|K": 833,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J?|K?|L?|M?|N": 944,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J?|K?|L?|M?|N?|O?|P?|Q?|R?|S?|T?|U?|V": 1019,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J?|K?|L?|M?|N?|O?|P?|Q?|R?|S?|T?|U?|V?|W?|X?|Y": 1172,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J?|K?|L?|M?|N?|O?|P?|Q?|R?|S?|T?|U?|V?|W?|X?|Y?|Z?|aa?|ab": 1374,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J?|K?|L?|M?|N?|O?|P?|Q?|R?|S?|T?|U?|V?|W?|X?|Y?|Z?|aa?|ab?|ac?|ad": 1741,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?|E?|F?|G?|H?|I?|J?": 1568,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?|D?": 1602,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?|C?": 1636,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?|B?": 1391,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?|A?": 1501,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?|z?": 989,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?|y?": 810,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?|x?": 661,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?|w?": 540,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?|v?": 428,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?|u?": 366,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?|t?": 336,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?|s?": 369,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?|r?": 355,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?|q?": 377,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?|p?": 351,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?}": 2105,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?|o?": 361,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?}": 1524,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?|n?": 380,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?}": 1478,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?|m?": 391,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?}": 1483,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?|l?": 342,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?}": 1262,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?|k?": 373,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?}": 958,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?|j?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?|j?": 385,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?}": 886,
+    "a?|b?|c?|d?|e?|f?|g?|h?|i?}-{a?|b?|c?|d?|e?|f?|g?|h?|i?": 421,
+    "a?|b?|c?|d?|e?|f?|g?|h?}": 1000,
+    "a?|b?|c?|d?|e?|f?|g?|h?}*OSO/3=O/3=O": 2035,
+    "a?|b?|c?|d?|e?|f?|g?|h?}-{a?|b?|c?|d?|e?|f?|g?|h?": 432,
+    "a?|b?|c?|d?|e?|f?|g?}": 1150,
+    "a?|b?|c?|d?|e?|f?|g?}-{a?|b?|c?|d?|e?|f?|g?": 446,
+    "a?|b?|c?|d?|e?|f?}": 834,
+    "a?|b?|c?|d?|e?|f?}*OC": 2110,
+    "a?|b?|c?|d?|e?|f?}*OSO/3=O/3=O": 1333,
+    "a?|b?|c?|d?|e?|f?}-{a?|b?|c?|d?|e?|f?": 442,
+    "a?|b?|c?|d?|e?}": 791,
+    "a?|b?|c?|d?|e?}*OC": 2034,
+    "a?|b?|c?|d?|e?}*OSO/3=O/3=O": 1253,
+    "a?|b?|c?|d?|e?}-{a?|b?|c?|d?|e?": 478,
+    "a?|b?|c?|d?}": 1923,
+    "a?|b?|c?|d?}*OC": 1951,
+    "a?|b?|c?|d?}*OSO/3=O/3=O": 1349,
+    "a?|b?|c?|d?}-{a?|b?|c?|d?": 489,
+    "a?|b?|c?}*OC": 1563,
+    "a?|b?|c?}*OCC/3=O": 1773,
+    "a?|b?|c?}*OSO/3=O/3=O": 2030,
+    "a?|b?|c?}-{a?|b?|c?": 604,
+    "a?|b?}*OSO/3=O/3=O": 2101,
+    "a?|b?}-{a?|b?": 996,
+    "b?-": 237,
+    "b?-c1": 251,
+    "b?-c2": 793,
+    "b?-d1": 1072,
+    "b?-e1": 910,
+    "b?-f1": 938,
+    "b?-g1": 1021,
+    "b?-h1": 1250,
+    "b?-i1": 1531,
+    "b?-j1": 1671,
+    "c?-": 229,
+    "c?-d1": 258,
+    "c?-d2": 1161,
+    "c?-e1": 880,
+    "c?-f1": 844,
+    "c?-g1": 711,
+    "c?-h1": 649,
+    "c?-i1": 654,
+    "c?-j1": 820,
+    "c?-k1": 720,
+    "c?-l1": 894,
+    "c?-m1": 1038,
+    "c?-n1": 1445,
+    "c?-o1": 1608,
+    "c?-p1": 1992,
+    "c?-q1": 1945,
+    "c?-r1": 2066,
+    "d?-": 247,
+    "d?-e1": 275,
+    "d?-e2": 1050,
+    "d?-f1": 961,
+    "d?-g1": 754,
+    "d?-h1": 640,
+    "d?-i1": 788,
+    "d?-j1": 1001,
+    "d?-k1": 1360,
+    "e?-": 276,
+    "e?-f1": 295,
+    "e?-f2": 1197,
+    "e?-g1": 953,
+    "e?-h1": 817,
+    "e?-i1": 1305,
+    "f1-a?|b?|c?|d?|e?}": 1798,
+    "f?-": 309,
+    "f?-g1": 363,
+    "f?-g2": 499,
+    "f?-h1": 1396,
+    "f?-i1": 1940,
+    "g1-a?|b?|c?|d?|e?|f?}": 1672,
+    "g?-": 329,
+    "g?-h1": 401,
+    "g?-h2": 885,
+    "g?-i1": 1178,
+    "g?-j1": 1513,
+    "h?-": 352,
+    "h?-i1": 409,
+    "h?-i2": 893,
+    "h?-j1": 1301,
+    "i1-a?|b?|c?|d?|e?|f?|g?|h?}": 1961,
+    "i1-a?|b?|c?|d?|e?}": 2077,
+    "i?-": 345,
+    "i?-j1": 415,
+    "i?-j2": 859,
+    "i?-k1": 1317,
+    "i?-l1": 1193,
+    "j1-a?|b?|c?|d?|e?|f?|g?|h?|i?}": 1905,
+    "j?-": 405,
+    "j?-k1": 470,
+    "j?-k2": 873,
+    "j?-l1": 1752,
+    "j?-m1": 1626,
+    "j?-n1": 2093,
+    "k?-": 416,
+    "k?-l1": 496,
+    "k?-l2": 1116,
+    "k?-m1": 1888,
+    "k?-n1": 1780,
+    "k?-o1": 1124,
+    "l?-": 450,
+    "l?-m1": 516,
+    "l?-m2": 1383,
+    "l?-n1": 1790,
+    "l?-o1": 1991,
+    "l?-p1": 1726,
+    "l?-q1": 1804,
+    "m?-": 481,
+    "m?-n1": 620,
+    "m?-n2": 950,
+    "m?-p1": 1686,
+    "m?-q1": 2021,
+    "m?-r1": 1948,
+    "n?-": 590,
+    "n?-o1": 734,
+    "n?-o2": 1220,
+    "n?-q1": 1893,
+    "o?-": 637,
+    "o?-p1": 752,
+    "o?-p2": 1503,
+    "p?-": 778,
+    "p?-q1": 952,
+    "p?-q2": 1433,
+    "q?-": 843,
+    "q?-r1": 1026,
+    "q?-r2": 1993,
+    "r?-": 963,
+    "r?-s1": 1138,
+    "s?-": 1173,
+    "s?-t1": 1428,
+    "t?-": 1829
+  },
+  "definition": "non-special vocabulary token containing literal question mark",
+  "schema": "bertose_a5_literal_question_mark_ambiguity_v1",
+  "source_vocabulary": "review_bpe_vocabulary.json",
+  "training_authorized": false
+}

releases/2026-10-02/iar_completion/runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_sequence_tree_runtime.py

@@ -0,0 +1,287 @@
+"""Fail-closed WURCS tree channels for the review-only A5 runtime.
+
+The fitted BPE vocabulary is deliberately not changed here.  This module only
+repairs deterministic transform-time annotations.  A tree depth is emitted
+only when every linkage is a full, unambiguous residue-pair token, exactly one
+endpoint of every bond is the anomeric donor, and the resulting directed graph
+is one rooted tree.  Otherwise residue tokens receive an explicit UNKNOWN
+depth while the original WURCS units remain available to BPE.
+
+This file is an isolated review runtime.  It must not be copied over the shared
+``training/a5_wurcs_bpe.py`` module.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict, deque
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from training.a5_topology import node_index, node_label
+from training.a5_wurcs_bpe import A5WURCSBPETokenizer, A5WURCSPreTokenizer
+
+
+BRANCH_DEPTH_UNKNOWN = 202
+BRANCH_DEPTH_VOCAB_SIZE = 203
+
+LINKAGE_NONE = 0
+LINKAGE_1_2 = 1
+LINKAGE_1_3 = 2
+LINKAGE_1_4 = 3
+LINKAGE_1_6 = 4
+LINKAGE_2_3 = 5
+LINKAGE_2_6 = 6
+LINKAGE_3_6 = 7
+LINKAGE_OTHER_EXACT = 8
+LINKAGE_UNKNOWN = 9
+LINKAGE_VOCAB_SIZE = 10
+
+
+@dataclass(frozen=True)
+class TreeChannelAnalysis:
+    residue_count: int
+    exact_undirected_tree: bool
+    exact_rooted_tree: bool
+    failure_reason: str
+    depths: dict[int, int]
+    branch_open_counts: dict[int, int]
+    distance_matrix: list[list[int]]
+
+
+def _distance_matrix(adjacency: dict[int, set[int]], count: int) -> list[list[int]]:
+    matrix: list[list[int]] = []
+    for source in range(count):
+        distances = {source: 0}
+        queue: deque[int] = deque([source])
+        while queue:
+            current = queue.popleft()
+            for neighbor in sorted(adjacency[current]):
+                if neighbor not in distances:
+                    distances[neighbor] = distances[current] + 1
+                    queue.append(neighbor)
+        if len(distances) != count:
+            return []
+        matrix.append([distances[target] for target in range(count)])
+    return matrix
+
+
+class ReviewA5WURCSPreTokenizerV3(A5WURCSPreTokenizer):
+    """A5 semantic units with fail-closed branch and linkage channels."""
+
+    def _sections(
+        self, wurcs: str
+    ) -> tuple[list[str], list[str], list[str], list[int | None]]:
+        parts = self._split_wurcs_sections(wurcs)
+        if len(parts) < 4:
+            return [], [], [], []
+        residue_definitions = self.RESIDUE_PATTERN.findall(parts[2])
+        index_list = parts[3].split("-") if parts[3] else []
+        linkages = parts[4].split("_") if len(parts) > 4 and parts[4] else []
+        anomeric = self._instance_anomeric_positions(residue_definitions, index_list)
+        return residue_definitions, index_list, linkages, anomeric
+
+    def analyze_tree(self, wurcs: str) -> TreeChannelAnalysis:
+        _, index_list, linkages, anomeric = self._sections(wurcs)
+        count = len(index_list)
+        if count == 0:
+            return TreeChannelAnalysis(0, False, False, "missing_residue_instances", {}, {}, [])
+        if count == 1:
+            if linkages:
+                return TreeChannelAnalysis(
+                    1, False, False, "single_residue_has_linkage_tokens", {}, {}, []
+                )
+            return TreeChannelAnalysis(1, True, True, "", {0: 0}, {}, [[0]])
+
+        adjacency: dict[int, set[int]] = {index: set() for index in range(count)}
+        directed_children: dict[int, list[int]] = defaultdict(list)
+        child_parent: dict[int, int] = {}
+        seen_edges: set[tuple[int, int]] = set()
+        orientation_failure = ""
+
+        for linkage in linkages:
+            match = self.A5_LINKAGE_PATTERN.fullmatch(linkage)
+            if match is None:
+                return TreeChannelAnalysis(
+                    count, False, False, "non_exact_linkage_token", {}, {}, []
+                )
+            left_label, left_position, right_label, right_position = match.groups()
+            try:
+                left = node_index(left_label) - 1
+                right = node_index(right_label) - 1
+            except ValueError:
+                return TreeChannelAnalysis(
+                    count, False, False, "invalid_residue_label", {}, {}, []
+                )
+            if not (0 <= left < count and 0 <= right < count) or left == right:
+                return TreeChannelAnalysis(
+                    count, False, False, "invalid_residue_edge", {}, {}, []
+                )
+            edge = tuple(sorted((left, right)))
+            if edge in seen_edges:
+                return TreeChannelAnalysis(
+                    count, False, False, "duplicate_residue_edge", {}, {}, []
+                )
+            seen_edges.add(edge)
+            adjacency[left].add(right)
+            adjacency[right].add(left)
+
+            left_is_donor = (
+                left_position != "?"
+                and anomeric[left] is not None
+                and int(left_position) == anomeric[left]
+            )
+            right_is_donor = (
+                right_position != "?"
+                and anomeric[right] is not None
+                and int(right_position) == anomeric[right]
+            )
+            if left_is_donor == right_is_donor:
+                orientation_failure = "bond_donor_not_unique"
+                continue
+            child = left if left_is_donor else right
+            parent = right if left_is_donor else left
+            if child in child_parent and child_parent[child] != parent:
+                orientation_failure = "residue_has_multiple_parents"
+                continue
+            child_parent[child] = parent
+            directed_children[parent].append(child)
+
+        if len(seen_edges) != count - 1:
+            return TreeChannelAnalysis(
+                count, False, False, "edge_count_not_residue_count_minus_one", {}, {}, []
+            )
+        distances = _distance_matrix(adjacency, count)
+        if not distances:
+            return TreeChannelAnalysis(
+                count, False, False, "residue_graph_disconnected", {}, {}, []
+            )
+        if orientation_failure:
+            return TreeChannelAnalysis(
+                count, True, False, orientation_failure, {}, {}, distances
+            )
+
+        roots = sorted(set(range(count)) - set(child_parent))
+        if len(roots) != 1:
+            return TreeChannelAnalysis(
+                count, True, False, "root_not_unique", {}, {}, distances
+            )
+        depths = {roots[0]: 0}
+        queue: deque[int] = deque([roots[0]])
+        while queue:
+            parent = queue.popleft()
+            for child in sorted(directed_children.get(parent, [])):
+                if child in depths:
+                    return TreeChannelAnalysis(
+                        count, True, False, "directed_cycle", {}, {}, distances
+                    )
+                depths[child] = depths[parent] + 1
+                queue.append(child)
+        if len(depths) != count:
+            return TreeChannelAnalysis(
+                count, True, False, "directed_tree_disconnected", {}, {}, distances
+            )
+        if max(depths.values()) >= BRANCH_DEPTH_UNKNOWN:
+            return TreeChannelAnalysis(
+                count, True, False, "exact_depth_collides_with_unknown_id", {}, {}, distances
+            )
+        branch_counts = {
+            parent: len(children) - 1
+            for parent, children in directed_children.items()
+            if len(children) > 1
+        }
+        return TreeChannelAnalysis(
+            count, True, True, "", depths, branch_counts, distances
+        )
+
+    @staticmethod
+    def exact_linkage_type(linkage: str) -> int:
+        match = ReviewA5WURCSPreTokenizerV3.A5_LINKAGE_PATTERN.fullmatch(linkage)
+        if match is None:
+            return LINKAGE_UNKNOWN
+        _, left_position, _, right_position = match.groups()
+        if left_position == "?" or right_position == "?":
+            return LINKAGE_UNKNOWN
+        positions = tuple(sorted((int(left_position), int(right_position))))
+        mapping = {
+            (1, 2): LINKAGE_1_2,
+            (1, 3): LINKAGE_1_3,
+            (1, 4): LINKAGE_1_4,
+            (1, 6): LINKAGE_1_6,
+            (2, 3): LINKAGE_2_3,
+            (2, 6): LINKAGE_2_6,
+            (3, 6): LINKAGE_3_6,
+        }
+        return mapping.get(positions, LINKAGE_OTHER_EXACT)
+
+    def pre_tokenize(self, wurcs: str) -> list[dict]:
+        # Reuse only the already-audited semantic WURCS unit extraction.  All
+        # v2 branch markers, depths, linkage classes, and distance matrices are
+        # discarded and rebuilt below.
+        inherited = super().pre_tokenize(wurcs)
+        units = [dict(unit) for unit in inherited if unit.get("text") != "[BRANCH_OPEN]"]
+        analysis = self.analyze_tree(wurcs)
+        first_unit_for_residue: set[int] = set()
+        repaired: list[dict] = []
+        for unit in units:
+            unit.pop("distance_matrix", None)
+            residue_id = int(unit.get("residue_id", -1))
+            unit["linkage_type"] = LINKAGE_NONE
+            if residue_id >= 0:
+                depth = (
+                    analysis.depths[residue_id]
+                    if analysis.exact_rooted_tree
+                    else BRANCH_DEPTH_UNKNOWN
+                )
+                unit["branch_depth"] = depth
+                if residue_id not in first_unit_for_residue:
+                    for _ in range(analysis.branch_open_counts.get(residue_id, 0)):
+                        repaired.append(
+                            {
+                                "text": "[BRANCH_OPEN]",
+                                "type": "special",
+                                "residue_id": -1,
+                                "branch_depth": depth,
+                                "linkage_type": LINKAGE_NONE,
+                            }
+                        )
+                    first_unit_for_residue.add(residue_id)
+            else:
+                unit["branch_depth"] = 0
+                if unit.get("type") == "linkage":
+                    unit["linkage_type"] = self.exact_linkage_type(str(unit["text"]))
+            repaired.append(unit)
+
+        if repaired:
+            repaired[0]["distance_matrix"] = analysis.distance_matrix
+            repaired[0]["tree_channels_valid"] = analysis.exact_rooted_tree
+            repaired[0]["tree_channel_failure_reason"] = analysis.failure_reason
+        return repaired
+
+
+class ReviewA5WURCSBPETokenizerV3(A5WURCSBPETokenizer):
+    """Existing train-only BPE vocabulary with repaired transform channels."""
+
+    def __init__(self, vocab_path: Optional[str | Path] = None) -> None:
+        super().__init__(vocab_path)
+        self.pre_tokenizer = ReviewA5WURCSPreTokenizerV3()
+
+    def tokenize_sequence(self, wurcs: str, max_length: int = 256) -> dict:
+        encoded = super().tokenize_sequence(wurcs, max_length=max_length)
+        analysis = self.pre_tokenizer.analyze_tree(wurcs)
+        encoded["tree_channels_valid"] = analysis.exact_rooted_tree
+        encoded["tree_channel_failure_reason"] = analysis.failure_reason
+        return encoded
+
+
+__all__ = [
+    "BRANCH_DEPTH_UNKNOWN",
+    "BRANCH_DEPTH_VOCAB_SIZE",
+    "LINKAGE_NONE",
+    "LINKAGE_OTHER_EXACT",
+    "LINKAGE_UNKNOWN",
+    "LINKAGE_VOCAB_SIZE",
+    "ReviewA5WURCSBPETokenizerV3",
+    "ReviewA5WURCSPreTokenizerV3",
+    "TreeChannelAnalysis",
+]

releases/2026-10-02/iar_completion/runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_training_a5_topology.py

@@ -0,0 +1,180 @@
+"""Residue-level shortest-path targets used by the A5 topology objective."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from collections import deque
+
+
+EDGE_RE = re.compile(
+    r"(?P<n1>[A-Za-z]+)(?P<p1>[0-9?]+)-(?P<n2>[A-Za-z]+)(?P<p2>[0-9?]+)"
+)
+RESDEF_RE = re.compile(r"\[([^\]]*)\]")
+WURCS_RES_INDEX_ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+
+def node_label(index: int) -> str:
+    if index < 1:
+        raise ValueError("WURCS residue indices are one-based")
+    letters = WURCS_RES_INDEX_ALPHABET
+    base = len(letters)
+    index -= 1
+    label = ""
+    while True:
+        label = letters[index % base] + label
+        index = index // base - 1
+        if index < 0:
+            return label
+
+
+def node_index(label: str) -> int:
+    if not label:
+        raise ValueError("WURCS residue label cannot be empty")
+    base = len(WURCS_RES_INDEX_ALPHABET)
+    value = 0
+    for character in label:
+        try:
+            digit = WURCS_RES_INDEX_ALPHABET.index(character) + 1
+        except ValueError as error:
+            raise ValueError(f"Invalid WURCS residue label: {label}") from error
+        value = value * base + digit
+    return value
+
+
+def split_wurcs_sections(body: str) -> list[str]:
+    sections: list[str] = []
+    current: list[str] = []
+    bracket_depth = 0
+    for character in body:
+        if character == "[":
+            bracket_depth += 1
+        elif character == "]" and bracket_depth:
+            bracket_depth -= 1
+        if character == "/" and bracket_depth == 0:
+            sections.append("".join(current))
+            current = []
+        else:
+            current.append(character)
+    sections.append("".join(current))
+    return sections
+
+
+def split_wurcs(wurcs: str) -> tuple[list[str], dict[str, str], str]:
+    if not wurcs.startswith("WURCS=2.0/"):
+        return [], {}, ""
+    parts = split_wurcs_sections(wurcs[len("WURCS=2.0/") :])
+    if len(parts) < 4:
+        return [], {}, ""
+    residue_definitions = RESDEF_RE.findall(parts[1])
+    sequence = parts[2].split("-") if parts[2] else []
+    node_to_residue: dict[str, str] = {}
+    for index, value in enumerate(sequence, start=1):
+        try:
+            residue = residue_definitions[int(value) - 1]
+        except (ValueError, IndexError):
+            residue = ""
+        node_to_residue[node_label(index)] = residue
+    return residue_definitions, node_to_residue, "/".join(parts[3:])
+
+
+def _hash_fields(*values: object) -> str:
+    payload = "\x1f".join(str(value) for value in values).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def build_residue_shortest_path(wurcs: str) -> dict[str, object]:
+    """Build the same immutable residue target frozen by the P0/P1 audit."""
+    _, node_to_residue, linkage_section = split_wurcs(wurcs)
+    node_ids = list(node_to_residue)
+    if not node_ids or any(not node_to_residue[node] for node in node_ids):
+        return _failure("missing_or_unmapped_residue_sequence", len(node_ids), 0)
+    if len(node_ids) < 2:
+        return _failure(
+            "fewer_than_two_residues_no_off_diagonal_target", len(node_ids), 0
+        )
+
+    adjacency: dict[str, set[str]] = {node: set() for node in node_ids}
+    parsed_edges: list[tuple[str, str]] = []
+    unparsed_tokens: list[str] = []
+    for token in linkage_section.split("_") if linkage_section else []:
+        match = EDGE_RE.fullmatch(token)
+        if not match:
+            if token:
+                unparsed_tokens.append(token)
+            continue
+        left, right = match.group("n1"), match.group("n2")
+        if left not in adjacency or right not in adjacency or left == right:
+            unparsed_tokens.append(token)
+            continue
+        parsed_edges.append(tuple(sorted((left, right))))
+        adjacency[left].add(right)
+        adjacency[right].add(left)
+
+    reason = ""
+    if unparsed_tokens:
+        reason = "one_or_more_edge_tokens_not_unambiguous_residue_pairs"
+    elif len(set(parsed_edges)) != len(parsed_edges):
+        reason = "duplicate_residue_edge"
+    elif len(parsed_edges) != len(node_ids) - 1:
+        reason = "edge_count_not_residue_count_minus_one"
+
+    seen = {node_ids[0]}
+    queue = deque([node_ids[0]])
+    while queue:
+        node = queue.popleft()
+        for neighbor in sorted(adjacency[node]):
+            if neighbor not in seen:
+                seen.add(neighbor)
+                queue.append(neighbor)
+    if not reason and len(seen) != len(node_ids):
+        reason = "residue_graph_disconnected"
+    if reason:
+        return _failure(reason, len(node_ids), len(parsed_edges))
+
+    matrix: list[list[int]] = []
+    for source in node_ids:
+        distance = {source: 0}
+        queue = deque([source])
+        while queue:
+            node = queue.popleft()
+            for neighbor in sorted(adjacency[node]):
+                if neighbor not in distance:
+                    distance[neighbor] = distance[node] + 1
+                    queue.append(neighbor)
+        matrix.append([distance[target] for target in node_ids])
+
+    matrix_payload = json.dumps(matrix, separators=(",", ":"))
+    matrix_sha256 = hashlib.sha256(matrix_payload.encode("utf-8")).hexdigest()
+    return {
+        "target_valid": True,
+        "failure_reason": "",
+        "residue_count": len(node_ids),
+        "parsed_edge_count": len(parsed_edges),
+        "valid_unordered_pair_count": len(node_ids) * (len(node_ids) - 1) // 2,
+        "matrix": matrix,
+        "matrix_sha256": matrix_sha256,
+        "target_identity_sha256": _hash_fields(
+            "residue_shortest_path_v2",
+            wurcs,
+            matrix_sha256,
+            len(node_ids),
+            len(parsed_edges),
+        ),
+        "schema": "residue_shortest_path_v2",
+    }
+
+
+def _failure(reason: str, residues: int, edges: int) -> dict[str, object]:
+    return {
+        "target_valid": False,
+        "failure_reason": reason,
+        "residue_count": residues,
+        "parsed_edge_count": edges,
+        "valid_unordered_pair_count": 0,
+        "matrix": [],
+        "matrix_sha256": "",
+        "target_identity_sha256": "",
+        "schema": "residue_shortest_path_v2",
+    }

releases/2026-10-02/iar_completion/runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_training_a5_wurcs_bpe.py

@@ -0,0 +1,368 @@
+"""Deterministic train-only WURCS BPE utilities for A5."""
+
+from __future__ import annotations
+
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Iterable, Optional
+
+from .a5_topology import node_index, node_label
+
+try:
+    from bert_training_v4.downstream_tasks.utils.wurcs_bpe_tokenizer import (
+        WURCSBPETokenizer,
+        WURCSPreTokenizer,
+    )
+except ImportError:
+    from ..bert_training_v4.downstream_tasks.utils.wurcs_bpe_tokenizer import (
+        WURCSBPETokenizer,
+        WURCSPreTokenizer,
+    )
+
+
+SUBMITTED_FIT_ALPHABET = tuple(
+    "#$%()*-./0123456789<=>?ABCDEFGHIJKLMNOPQRSTUVWXYZ^abcdefghijklmnopqrstuvwxyz{|}~"
+)
+
+
+class _TopLevelBracketPattern:
+    """Expose regex-like findall while respecting nested SMILES brackets."""
+
+    @staticmethod
+    def findall(text: str) -> list[str]:
+        residues: list[str] = []
+        depth = 0
+        start = -1
+        for index, character in enumerate(text):
+            if character == "[":
+                if depth == 0:
+                    start = index + 1
+                depth += 1
+            elif character == "]" and depth:
+                depth -= 1
+                if depth == 0 and start >= 0:
+                    residues.append(text[start:index])
+                    start = -1
+        if depth:
+            return []
+        return residues
+
+
+class A5WURCSPreTokenizer(WURCSPreTokenizer):
+    """Submitted pre-tokenizer with nested bracket-safe residue extraction."""
+
+    A5_LINKAGE_PATTERN = re.compile(
+        r"([A-Za-z]+)(\d+|\?)-([A-Za-z]+)(\d+|\?)"
+    )
+    A5_ANOMERIC_PATTERN = re.compile(r"-([0-9]+)([abuxo])(?:_|$)")
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.RESIDUE_PATTERN = _TopLevelBracketPattern()
+
+    def _split_wurcs_sections(self, wurcs: str) -> list[str]:
+        sections = super()._split_wurcs_sections(wurcs)
+        if len(sections) <= 5:
+            return sections
+        # WURCS LIN modifications may contain unbracketed slashes. The format
+        # has exactly five top-level sections, so every trailing fragment
+        # belongs to the linkage section rather than a new section.
+        return sections[:4] + ["/".join(sections[4:])]
+
+    def _instance_anomeric_positions(
+        self, residue_definitions: list[str], index_list: list[str]
+    ) -> list[int | None]:
+        positions: list[int | None] = []
+        for definition_index in index_list:
+            try:
+                residue_definition = residue_definitions[int(definition_index) - 1]
+            except (IndexError, ValueError):
+                positions.append(None)
+                continue
+            match = self.A5_ANOMERIC_PATTERN.search(residue_definition)
+            positions.append(int(match.group(1)) if match is not None else None)
+        return positions
+
+    def _analyze_a5_tree(
+        self,
+        linkages: list[str],
+        residue_count: int,
+        anomeric_positions: list[int | None] | None = None,
+    ) -> tuple[dict[str, int], dict[str, int], dict[int, list[int]]]:
+        branch_points: dict[str, int] = defaultdict(int)
+        children: dict[str, list[str]] = defaultdict(list)
+        all_residues: set[str] = set()
+        adjacency: dict[int, list[int]] = defaultdict(list)
+        for linkage in linkages:
+            match = self.A5_LINKAGE_PATTERN.match(linkage)
+            if not match:
+                continue
+            left, left_position, right, right_position = match.groups()
+            try:
+                left_index = node_index(left) - 1
+                right_index = node_index(right) - 1
+            except ValueError:
+                continue
+            if not (
+                0 <= left_index < residue_count
+                and 0 <= right_index < residue_count
+                and left_index != right_index
+            ):
+                continue
+            parent, child = left, right
+            if anomeric_positions is not None:
+                left_anomeric = anomeric_positions[left_index]
+                right_anomeric = anomeric_positions[right_index]
+                left_is_donor = (
+                    left_position != "?"
+                    and left_anomeric is not None
+                    and int(left_position) == left_anomeric
+                )
+                right_is_donor = (
+                    right_position != "?"
+                    and right_anomeric is not None
+                    and int(right_position) == right_anomeric
+                )
+                if left_is_donor and not right_is_donor:
+                    parent, child = right, left
+                elif right_is_donor and not left_is_donor:
+                    parent, child = left, right
+            children[parent].append(child)
+            all_residues.update((parent, child))
+            adjacency[left_index].append(right_index)
+            adjacency[right_index].append(left_index)
+
+        for residue, child_labels in children.items():
+            if len(child_labels) > 1:
+                branch_points[residue] = len(child_labels) - 1
+        child_set = {child for values in children.values() for child in values}
+        roots = all_residues - child_set
+        root = min(roots, key=node_index) if roots else node_label(1)
+        depths = {root: 0}
+        queue = [root]
+        while queue:
+            current = queue.pop(0)
+            for child in children.get(current, []):
+                if child not in depths:
+                    depths[child] = depths[current] + 1
+                    queue.append(child)
+        return dict(branch_points), depths, adjacency
+
+    def _a5_linkage_type(self, linkage: str) -> int:
+        match = self.A5_LINKAGE_PATTERN.match(linkage)
+        if not match:
+            return 8
+        _, from_position, _, to_position = match.groups()
+        try:
+            positions = (int(from_position), int(to_position))
+        except ValueError:
+            return 8
+        linkage_types = {
+            (1, 2): 0,
+            (2, 1): 0,
+            (1, 3): 1,
+            (3, 1): 1,
+            (1, 4): 2,
+            (4, 1): 2,
+            (1, 6): 3,
+            (6, 1): 3,
+            (2, 3): 4,
+            (3, 2): 4,
+            (2, 6): 5,
+            (6, 2): 5,
+            (3, 6): 6,
+            (6, 3): 6,
+        }
+        return linkage_types.get(positions, 7)
+
+    def pre_tokenize(self, wurcs: str) -> list[dict]:
+        # Reuse the submitted semantic split, then correct only its tree
+        # annotations. This keeps the BPE unit text and special-token behavior.
+        inherited_units = super().pre_tokenize(wurcs)
+        try:
+            parts = self._split_wurcs_sections(wurcs)
+            index_list = parts[3].split("-") if len(parts) > 3 and parts[3] else []
+            linkages = parts[4].split("_") if len(parts) > 4 and parts[4] else []
+            residue_definitions = self.RESIDUE_PATTERN.findall(parts[2])
+            anomeric_positions = self._instance_anomeric_positions(
+                residue_definitions, index_list
+            )
+            branch_points, depths, adjacency = self._analyze_a5_tree(
+                linkages, len(index_list), anomeric_positions
+            )
+        except (IndexError, ValueError):
+            return inherited_units
+
+        units: list[dict] = []
+        opened_residues: set[int] = set()
+        for inherited in inherited_units:
+            if inherited.get("text") == "[BRANCH_OPEN]":
+                continue
+            unit = dict(inherited)
+            residue_id = int(unit.get("residue_id", -1))
+            if residue_id >= 0:
+                label = node_label(residue_id + 1)
+                if residue_id not in opened_residues:
+                    for _ in range(branch_points.get(label, 0)):
+                        units.append(
+                            {
+                                "text": "[BRANCH_OPEN]",
+                                "type": "special",
+                                "residue_id": -1,
+                                "branch_depth": depths.get(label, 0),
+                                "linkage_type": 0,
+                            }
+                        )
+                    opened_residues.add(residue_id)
+                unit["branch_depth"] = depths.get(label, 0)
+            elif unit.get("type") == "linkage":
+                unit["linkage_type"] = self._a5_linkage_type(str(unit["text"]))
+            units.append(unit)
+
+        if units:
+            units[0]["distance_matrix"] = self._compute_distance_matrix(
+                adjacency, len(index_list)
+            )
+        return units
+
+
+class A5WURCSBPETokenizer(WURCSBPETokenizer):
+    """Train-only BPE with a fit-derived alphabet and deterministic merge ties."""
+
+    def __init__(self, vocab_path: Optional[str | Path] = None) -> None:
+        super().__init__(str(vocab_path) if vocab_path is not None else None)
+        self.pre_tokenizer = A5WURCSPreTokenizer()
+
+    @classmethod
+    def train_from_fit_corpus(
+        cls,
+        wurcs_strings: Iterable[str],
+        num_merges: int = 2000,
+        output_path: Optional[str | Path] = None,
+        min_frequency: int = 2,
+        max_token_length: Optional[int] = None,
+    ) -> "A5WURCSBPETokenizer":
+        tokenizer = cls()
+        pre_tokenizer = tokenizer.pre_tokenizer
+        unit_counts: Counter[str] = Counter()
+        for wurcs in wurcs_strings:
+            for unit in pre_tokenizer.pre_tokenize(wurcs):
+                if unit["type"] != "special":
+                    unit_counts[unit["text"]] += 1
+
+        # The submitted tokenizer learned the base character inventory from its
+        # corpus. Preserve that behavior, but fit it from training parents only.
+        tokenizer.fit_alphabet = tuple(
+            sorted({char for unit in unit_counts for char in unit})
+        )
+
+        next_id = len(tokenizer.special_tokens)
+        for char in tokenizer.fit_alphabet:
+            tokenizer.token_to_id[char] = next_id
+            tokenizer.id_to_token[next_id] = char
+            next_id += 1
+
+        word_freqs: dict[tuple[str, ...], int] = {
+            tuple(unit): count
+            for unit, count in sorted(unit_counts.items())
+            if count >= min_frequency
+        }
+        merges: list[tuple[str, str]] = []
+        for _ in range(num_merges):
+            pair_counts: Counter[tuple[str, str]] = Counter()
+            for word, frequency in word_freqs.items():
+                for index in range(len(word) - 1):
+                    pair_counts[(word[index], word[index + 1])] += frequency
+            candidates = [
+                (pair, count)
+                for pair, count in pair_counts.items()
+                if count >= min_frequency
+                and (
+                    max_token_length is None
+                    or len(pair[0]) + len(pair[1]) <= max_token_length
+                )
+            ]
+            if not candidates:
+                break
+            best_pair, _ = min(
+                candidates,
+                key=lambda item: (-item[1], item[0][0], item[0][1]),
+            )
+            new_token = best_pair[0] + best_pair[1]
+            merges.append(best_pair)
+            tokenizer.token_to_id[new_token] = next_id
+            tokenizer.id_to_token[next_id] = new_token
+            next_id += 1
+
+            merged_freqs: Counter[tuple[str, ...]] = Counter()
+            for word, frequency in word_freqs.items():
+                merged_word: list[str] = []
+                index = 0
+                while index < len(word):
+                    if (
+                        index < len(word) - 1
+                        and word[index] == best_pair[0]
+                        and word[index + 1] == best_pair[1]
+                    ):
+                        merged_word.append(new_token)
+                        index += 2
+                    else:
+                        merged_word.append(word[index])
+                        index += 1
+                merged_freqs[tuple(merged_word)] += frequency
+            word_freqs = dict(merged_freqs)
+
+        tokenizer.merges = merges
+        if output_path is not None:
+            tokenizer.save_vocab(str(output_path))
+        return tokenizer
+
+    def tokenize_sequence(self, wurcs: str, max_length: int = 256) -> dict:
+        units = self.pre_tokenizer.pre_tokenize(wurcs)
+        tokens: list[str] = []
+        token_ids: list[int] = []
+        residue_ids: list[int] = []
+        branch_depths: list[int] = []
+        linkage_types: list[int] = []
+
+        for unit in units:
+            unit_tokens = (
+                [unit["text"]]
+                if unit["type"] == "special"
+                else self.apply_bpe(unit["text"])
+            )
+            for token in unit_tokens:
+                tokens.append(token)
+                token_ids.append(
+                    self.token_to_id.get(token, self.token_to_id["[UNK]"])
+                )
+                residue_ids.append(int(unit["residue_id"]))
+                branch_depths.append(int(unit["branch_depth"]))
+                linkage_types.append(int(unit["linkage_type"]))
+
+        if len(tokens) > max_length:
+            tokens = tokens[: max_length - 1] + ["[END]"]
+            token_ids = token_ids[: max_length - 1] + [self.token_to_id["[END]"]]
+            residue_ids = residue_ids[: max_length - 1] + [-1]
+            branch_depths = branch_depths[: max_length - 1] + [0]
+            linkage_types = linkage_types[: max_length - 1] + [0]
+
+        length = len(tokens)
+        attention_mask = [1] * length
+        padding = max_length - length
+        tokens.extend(["[PAD]"] * padding)
+        token_ids.extend([self.token_to_id["[PAD]"]] * padding)
+        residue_ids.extend([-1] * padding)
+        branch_depths.extend([0] * padding)
+        linkage_types.extend([0] * padding)
+        attention_mask.extend([0] * padding)
+        return {
+            "tokens": tokens,
+            "token_ids": token_ids,
+            "residue_ids": residue_ids,
+            "branch_depths": branch_depths,
+            "linkage_types": linkage_types,
+            "attention_mask": attention_mask,
+            "length": length,
+        }

releases/2026-10-02/iar_completion/runtime_snapshot/project/writing/cluster/nature_submission/code/model/__init__.py

@@ -0,0 +1,3 @@
+# Model module
+from .multimodal_glycan_bert_v3 import MultimodalGlycanBERT, MultimodalGlycanBERTConfig
+

releases/2026-10-02/iar_completion/runtime_snapshot/project/writing/cluster/nature_submission/code/model/glycan_bert.py

@@ -0,0 +1,303 @@
+"""
+Glycan BERT Model
+
+Transformer-based masked language model for glycan structures.
+Based on BERT/ESM2 architecture adapted for atomic glycan tokenization.
+"""
+
+import torch
+import torch.nn as nn
+import math
+
+
+class GlycanBERTConfig:
+    """Configuration for GlycanBERT."""
+    
+    def __init__(
+        self,
+        vocab_size: int = 102,
+        hidden_size: int = 384,
+        num_hidden_layers: int = 6,
+        num_attention_heads: int = 6,
+        intermediate_size: int = 1536,
+        hidden_dropout_prob: float = 0.1,
+        attention_probs_dropout_prob: float = 0.1,
+        max_position_embeddings: int = 512,
+        layer_norm_eps: float = 1e-12,
+        pad_token_id: int = 0,
+        mask_token_id: int = 4,
+        initializer_range: float = 0.02
+    ):
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.num_attention_heads = num_attention_heads
+        self.intermediate_size = intermediate_size
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.max_position_embeddings = max_position_embeddings
+        self.layer_norm_eps = layer_norm_eps
+        self.pad_token_id = pad_token_id
+        self.mask_token_id = mask_token_id
+        self.initializer_range = initializer_range
+
+
+class GlycanBERTEmbeddings(nn.Module):
+    """
+    Embeddings for glycan tokens including token and positional embeddings.
+    """
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        self.token_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id)
+        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
+        
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        
+        # position_ids (1, max_seq_len) is contiguous in memory and exported when serialized
+        self.register_buffer("position_ids", torch.arange(config.max_position_embeddings).expand((1, -1)))
+    
+    def forward(self, input_ids: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            input_ids: Tensor of shape (batch_size, seq_len)
+        
+        Returns:
+            Embeddings of shape (batch_size, seq_len, hidden_size)
+        """
+        batch_size, seq_len = input_ids.shape
+        
+        # Token embeddings
+        token_embeds = self.token_embeddings(input_ids)
+        
+        # Position embeddings
+        position_ids = self.position_ids[:, :seq_len]
+        position_embeds = self.position_embeddings(position_ids)
+        
+        # Combine
+        embeddings = token_embeds + position_embeds
+        embeddings = self.LayerNorm(embeddings)
+        embeddings = self.dropout(embeddings)
+        
+        return embeddings
+
+
+class GlycanBERTAttention(nn.Module):
+    """Multi-head self-attention."""
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        assert config.hidden_size % config.num_attention_heads == 0
+        
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = config.hidden_size // config.num_attention_heads
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+        
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+        
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+    
+    def transpose_for_scores(self, x: torch.Tensor) -> torch.Tensor:
+        """Reshape for multi-head attention."""
+        new_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(*new_shape)
+        return x.permute(0, 2, 1, 3)  # (batch, heads, seq_len, head_size)
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Args:
+            hidden_states: (batch_size, seq_len, hidden_size)
+            attention_mask: (batch_size, seq_len) - 1 for valid, 0 for padding
+        
+        Returns:
+            Attention output: (batch_size, seq_len, hidden_size)
+        """
+        batch_size, seq_len, _ = hidden_states.shape
+        
+        # Linear projections
+        query_layer = self.transpose_for_scores(self.query(hidden_states))
+        key_layer = self.transpose_for_scores(self.key(hidden_states))
+        value_layer = self.transpose_for_scores(self.value(hidden_states))
+        
+        # Attention scores
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        
+        # Apply attention mask
+        if attention_mask is not None:
+            # Convert mask to additive mask
+            attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)  # (batch, 1, 1, seq_len)
+            attention_mask = (1.0 - attention_mask) * -10000.0
+            attention_scores = attention_scores + attention_mask
+        
+        # Attention probabilities
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+        attention_probs = self.dropout(attention_probs)
+        
+        # Apply attention to values
+        context_layer = torch.matmul(attention_probs, value_layer)
+        
+        # Reshape back
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(*new_shape)
+        
+        return context_layer
+
+
+class GlycanBERTLayer(nn.Module):
+    """Single transformer layer."""
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        self.attention = GlycanBERTAttention(config)
+        self.attention_output = nn.Linear(config.hidden_size, config.hidden_size)
+        self.attention_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        
+        self.intermediate = nn.Linear(config.hidden_size, config.intermediate_size)
+        self.output = nn.Linear(config.intermediate_size, config.hidden_size)
+        self.output_layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Args:
+            hidden_states: (batch_size, seq_len, hidden_size)
+            attention_mask: (batch_size, seq_len)
+        
+        Returns:
+            Output: (batch_size, seq_len, hidden_size)
+        """
+        # Self-attention
+        attention_output = self.attention(hidden_states, attention_mask)
+        attention_output = self.attention_output(attention_output)
+        attention_output = self.dropout(attention_output)
+        
+        # Add & Norm
+        hidden_states = self.attention_layer_norm(hidden_states + attention_output)
+        
+        # Feed-forward
+        intermediate_output = self.intermediate(hidden_states)
+        intermediate_output = nn.functional.gelu(intermediate_output)
+        
+        layer_output = self.output(intermediate_output)
+        layer_output = self.dropout(layer_output)
+        
+        # Add & Norm
+        layer_output = self.output_layer_norm(hidden_states + layer_output)
+        
+        return layer_output
+
+
+class GlycanBERT(nn.Module):
+    """
+    Glycan BERT model for masked language modeling.
+    """
+    
+    def __init__(self, config: GlycanBERTConfig):
+        super().__init__()
+        self.config = config
+        
+        # Embeddings
+        self.embeddings = GlycanBERTEmbeddings(config)
+        
+        # Transformer layers
+        self.layers = nn.ModuleList([GlycanBERTLayer(config) for _ in range(config.num_hidden_layers)])
+        
+        # MLM head
+        self.mlm_head = nn.Linear(config.hidden_size, config.vocab_size)
+        
+        # Initialize weights
+        self.apply(self._init_weights)
+    
+    def _init_weights(self, module):
+        """Initialize weights."""
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+    
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor = None,
+        labels: torch.Tensor = None
+    ):
+        """
+        Args:
+            input_ids: (batch_size, seq_len)
+            attention_mask: (batch_size, seq_len) - 1 for valid, 0 for padding
+            labels: (batch_size, seq_len) - token IDs to predict, -100 for positions to ignore
+        
+        Returns:
+            If labels provided: (loss, logits)
+            Else: logits
+        """
+        # Create attention mask if not provided
+        if attention_mask is None:
+            attention_mask = (input_ids != self.config.pad_token_id).float()
+        
+        # Embeddings
+        hidden_states = self.embeddings(input_ids)
+        
+        # Transformer layers
+        for layer in self.layers:
+            hidden_states = layer(hidden_states, attention_mask)
+        
+        # MLM prediction
+        logits = self.mlm_head(hidden_states)
+        
+        # Calculate loss if labels provided
+        loss = None
+        if labels is not None:
+            loss_fct = nn.CrossEntropyLoss()  # -100 is ignored
+            loss = loss_fct(logits.view(-1, self.config.vocab_size), labels.view(-1))
+        
+        if loss is not None:
+            return loss, logits
+        return logits
+    
+    def get_embeddings(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor = None
+    ) -> torch.Tensor:
+        """
+        Get contextualized embeddings (for downstream tasks).
+        
+        Args:
+            input_ids: (batch_size, seq_len)
+            attention_mask: (batch_size, seq_len)
+        
+        Returns:
+            Embeddings: (batch_size, seq_len, hidden_size)
+        """
+        if attention_mask is None:
+            attention_mask = (input_ids != self.config.pad_token_id).float()
+        
+        hidden_states = self.embeddings(input_ids)
+        
+        for layer in self.layers:
+            hidden_states = layer(hidden_states, attention_mask)
+        
+        return hidden_states
+

releases/2026-10-02/iar_completion/runtime_snapshot/project/writing/cluster/nature_submission/code/model/multimodal_glycan_bert_v3.py

@@ -0,0 +1,1084 @@
+"""
+Multimodal Glycan BERT Model v3
+
+Extends GlycanBERT to handle three modalities:
+- Sequence (WURCS atomic tokenization)
+- MS (mass spectrometry peaks, RT, intensity)
+- 3D structure (VQ-VAE discrete tokens, 4 per residue)
+
+Each modality has its own encoder, with cross-attention for sequence-structure alignment.
+"""
+
+import torch
+import torch.nn as nn
+from typing import Dict, Optional, Tuple
+import math
+
+try:
+    from .glycan_bert import GlycanBERTConfig, GlycanBERTEmbeddings, GlycanBERTLayer
+except ImportError:
+    from glycan_bert import GlycanBERTConfig, GlycanBERTEmbeddings, GlycanBERTLayer
+
+
+class ConvGlycanBERTEmbeddings(nn.Module):
+    """
+    Improved Convolutional front-end that mixes local WURCS context before the Transformer.
+    
+    Key improvements over original:
+    1. Position embeddings added BEFORE convolution (provides spatial context to conv)
+    2. Residual connection (conv enriches embeddings rather than replacing them)
+    3. Multi-scale convolutions (kernel sizes 3, 5, 7) for better receptive field
+    4. Proper layer normalization on the residual path
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        self.token_embeddings = nn.Embedding(
+            config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id
+        )
+        self.position_embeddings = nn.Embedding(
+            config.max_position_embeddings, config.hidden_size
+        )
+        
+        # NEW: Branch depth embeddings - encodes depth in glycan tree (0=root, 1=child, etc.)
+        max_branch_depth = getattr(config, "max_branch_depth", 8)
+        self.branch_embeddings = nn.Embedding(max_branch_depth, config.hidden_size)
+        
+        # NEW: Linkage type embeddings - encodes chemistry of glycosidic bond
+        # 0=none, 1=1-3, 2=1-4, 3=1-6, etc.
+        num_linkage_types = getattr(config, "num_linkage_types", 9)
+        self.linkage_embeddings = nn.Embedding(num_linkage_types, config.hidden_size)
+        
+        # Multi-scale convolutions for different receptive fields
+        kernel_size = getattr(config, "cnn_kernel_size", 3)
+        # Split channels evenly: 256 + 256 + 256 = 768 for hidden_size=768
+        channels_per_scale = config.hidden_size // 3
+        self.conv_layers = nn.ModuleList([
+            nn.Conv1d(
+                in_channels=config.hidden_size,
+                out_channels=channels_per_scale,
+                kernel_size=kernel_size + 2 * i,  # Kernels: 3, 5, 7
+                padding=(kernel_size + 2 * i) // 2,  # Same padding
+            )
+            for i in range(3)
+        ])
+        self.conv_activation = nn.GELU()
+        self.conv_proj = nn.Linear(channels_per_scale * 3, config.hidden_size)  # Project concatenated back
+        
+        self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.conv_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.register_buffer(
+            "position_ids",
+            torch.arange(config.max_position_embeddings).expand((1, -1)),
+        )
+
+        self.hidden_size = config.hidden_size
+
+    def forward(self, input_ids, branch_depths=None, linkage_types=None):
+        seq_len = input_ids.shape[1]
+        
+        # Step 1: Token + Position embeddings FIRST (provides spatial context to conv)
+        x = self.token_embeddings(input_ids)  # (batch, seq, hidden)
+        position_ids = self.position_ids[:, :seq_len]
+        x = x + self.position_embeddings(position_ids)
+        
+        # NEW: Add branch depth embeddings (encodes tree structure)
+        if branch_depths is not None:
+            # Clamp to valid range
+            branch_depths = branch_depths.clamp(0, self.branch_embeddings.num_embeddings - 1)
+            x = x + self.branch_embeddings(branch_depths)
+        
+        # NEW: Add linkage type embeddings (encodes bond chemistry)
+        if linkage_types is not None:
+            linkage_types = linkage_types.clamp(0, self.linkage_embeddings.num_embeddings - 1)
+            x = x + self.linkage_embeddings(linkage_types)
+        
+        x = self.LayerNorm(x)
+        
+        # Step 2: Multi-scale convolution with RESIDUAL connection
+        # Convolution expects (batch, hidden, seq)
+        conv_in = x.permute(0, 2, 1)
+        
+        # Apply multi-scale convolutions and concatenate
+        conv_outputs = []
+        for conv in self.conv_layers:
+            conv_out = self.conv_activation(conv(conv_in))
+            conv_outputs.append(conv_out)
+        
+        # Concatenate multi-scale features and project back
+        conv_out = torch.cat(conv_outputs, dim=1)  # (batch, hidden, seq)
+        conv_out = conv_out.permute(0, 2, 1)  # (batch, seq, hidden)
+        conv_out = self.conv_proj(conv_out)  # Project to correct size
+        
+        # Step 3: Residual connection - conv ENRICHES rather than replaces
+        x = self.conv_norm(x + self.dropout(conv_out))
+        
+        return x
+
+
+def create_residue_level_mask(
+    seq_residue_ids: torch.Tensor,    # (batch, N_seq)
+    struct_residue_ids: torch.Tensor  # (batch, N_struct)
+) -> torch.Tensor:
+    """
+    Create residue-level attention mask for cross-attention.
+    
+    Maps WURCS tokens to VQ-VAE structural tokens based on residue IDs.
+    A WURCS token with residue_id=0 can only attend to VQ-VAE tokens with residue_id=0.
+    
+    Args:
+        seq_residue_ids: Residue IDs for sequence tokens (batch, N_seq)
+        struct_residue_ids: Residue IDs for structural tokens (batch, N_struct)
+    
+    Returns:
+        Boolean mask (batch, N_seq, N_struct) where True = can attend
+    """
+    # Expand dimensions for broadcasting
+    # seq: (batch, N_seq, 1)
+    # struct: (batch, 1, N_struct)
+    mask = seq_residue_ids.unsqueeze(2) == struct_residue_ids.unsqueeze(1)
+    # Shape: (batch, N_seq, N_struct)
+    
+    # Mask out structural tokens (residue_id = -1) and MS tokens (residue_id = -2)
+    # Only tokens with residue_id >= 0 can attend
+    mask &= (seq_residue_ids.unsqueeze(2) >= 0)
+    
+    return mask  # True = can attend, False = cannot attend
+
+
+class MultimodalGlycanBERTConfig:
+    """Configuration for Multimodal GlycanBERT v3."""
+    
+    def __init__(
+        self,
+        # Sequence modality
+        seq_vocab_size: int = 166,
+        seq_hidden_size: int = 768,
+        seq_num_layers: int = 12,
+        seq_num_heads: int = 12,
+        seq_max_length: int = 512,
+        
+        # MS modality
+        ms_vocab_size: int = 242,
+        ms_hidden_size: int = 384,
+        ms_num_layers: int = 6,
+        ms_num_heads: int = 6,
+        ms_max_length: int = 150,
+        
+        # 3D structure modality
+        struct_vocab_size: int = 1024,  # VQ-VAE codebook size
+        struct_hidden_size: int = 512,
+        struct_num_layers: int = 8,
+        struct_num_heads: int = 8,
+        struct_max_length: int = 200,
+        use_3d: bool = True,
+        
+        # Cross-attention
+        use_cross_attention: bool = True,
+        cross_attn_num_heads: int = 8,
+        
+        # Fusion
+        fusion_hidden_size: int = 768,
+        fusion_num_layers: int = 2,
+        
+        # Training
+        hidden_dropout_prob: float = 0.1,
+        attention_probs_dropout_prob: float = 0.1,
+        layer_norm_eps: float = 1e-12,
+        initializer_range: float = 0.02,
+
+        # Conv front-end
+        use_cnn_frontend: bool = True,
+        cnn_kernel_size: int = 3,
+        
+        # Loss weights
+        seq_loss_weight: float = 0.60,
+        ms_loss_weight: float = 0.15,
+        struct_loss_weight: float = 0.25,
+        dist_loss_weight: float = 0.25,
+        
+        # Token IDs
+        pad_token_id: int = 0,
+        mask_token_id: int = 1,
+    ):
+        # Sequence config
+        self.seq_vocab_size = seq_vocab_size
+        self.seq_hidden_size = seq_hidden_size
+        self.seq_num_layers = seq_num_layers
+        self.seq_num_heads = seq_num_heads
+        self.seq_max_length = seq_max_length
+        
+        # MS config
+        self.ms_vocab_size = ms_vocab_size
+        self.ms_vocab_offset = seq_vocab_size  # MS tokens start at 166
+        self.ms_total_vocab_size = seq_vocab_size + ms_vocab_size  # 408 total
+        self.ms_hidden_size = ms_hidden_size
+        self.ms_num_layers = ms_num_layers
+        self.ms_num_heads = ms_num_heads
+        self.ms_max_length = ms_max_length
+        
+        # Structure config
+        self.struct_vocab_size = struct_vocab_size
+        self.struct_hidden_size = struct_hidden_size
+        self.struct_num_layers = struct_num_layers
+        self.struct_num_heads = struct_num_heads
+        self.struct_max_length = struct_max_length
+        self.use_3d = use_3d
+        
+        # Cross-attention config
+        self.use_cross_attention = use_cross_attention
+        self.cross_attn_num_heads = cross_attn_num_heads
+        
+        # Fusion config
+        self.fusion_hidden_size = fusion_hidden_size
+        self.fusion_num_layers = fusion_num_layers
+        
+        # Training config
+        self.hidden_dropout_prob = hidden_dropout_prob
+        self.attention_probs_dropout_prob = attention_probs_dropout_prob
+        self.layer_norm_eps = layer_norm_eps
+        self.initializer_range = initializer_range
+
+        # Conv front-end
+        self.use_cnn_frontend = use_cnn_frontend
+        self.cnn_kernel_size = cnn_kernel_size
+        
+        # Loss weights
+        self.seq_loss_weight = seq_loss_weight
+        self.ms_loss_weight = ms_loss_weight
+        self.struct_loss_weight = struct_loss_weight
+        self.dist_loss_weight = dist_loss_weight
+        
+        # Token IDs
+        self.pad_token_id = pad_token_id
+        self.mask_token_id = mask_token_id
+    
+    def to_seq_config(self) -> GlycanBERTConfig:
+        """Convert to sequence-only config."""
+        return GlycanBERTConfig(
+            vocab_size=self.seq_vocab_size,
+            hidden_size=self.seq_hidden_size,
+            num_hidden_layers=self.seq_num_layers,
+            num_attention_heads=self.seq_num_heads,
+            intermediate_size=self.seq_hidden_size * 4,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.seq_max_length,
+            layer_norm_eps=self.layer_norm_eps,
+            pad_token_id=self.pad_token_id,
+            mask_token_id=self.mask_token_id,
+            initializer_range=self.initializer_range,
+        )
+    
+    def to_ms_config(self) -> GlycanBERTConfig:
+        """Convert to MS-only config."""
+        return GlycanBERTConfig(
+            vocab_size=self.ms_total_vocab_size,
+            hidden_size=self.ms_hidden_size,
+            num_hidden_layers=self.ms_num_layers,
+            num_attention_heads=self.ms_num_heads,
+            intermediate_size=self.ms_hidden_size * 4,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.ms_max_length,
+            layer_norm_eps=self.layer_norm_eps,
+            pad_token_id=self.pad_token_id,
+            mask_token_id=self.mask_token_id,
+            initializer_range=self.initializer_range,
+        )
+    
+    def to_struct_config(self) -> GlycanBERTConfig:
+        """Convert to structure-only config."""
+        return GlycanBERTConfig(
+            vocab_size=self.struct_vocab_size,
+            hidden_size=self.struct_hidden_size,
+            num_hidden_layers=self.struct_num_layers,
+            num_attention_heads=self.struct_num_heads,
+            intermediate_size=self.struct_hidden_size * 4,
+            hidden_dropout_prob=self.hidden_dropout_prob,
+            attention_probs_dropout_prob=self.attention_probs_dropout_prob,
+            max_position_embeddings=self.struct_max_length,
+            layer_norm_eps=self.layer_norm_eps,
+            pad_token_id=self.pad_token_id,
+            mask_token_id=self.mask_token_id,
+            initializer_range=self.initializer_range,
+        )
+
+
+# =============================================================================
+# Improvement #1: Monosaccharide-Level Pooling
+# =============================================================================
+
+class MonosaccharidePooling(nn.Module):
+    """
+    Pool token representations to monosaccharide level, then aggregate.
+    
+    This bridges the gap between token-level BERT and monosaccharide-level CNNs/GNNs.
+    Uses monosaccharide_indices from the data to know where each residue starts.
+    """
+    
+    def __init__(self, hidden_size: int, num_attention_heads: int = 8, dropout: float = 0.1):
+        super().__init__()
+        self.hidden_size = hidden_size
+        
+        # Attention pooling over monosaccharide representations
+        self.mono_attention = nn.MultiheadAttention(
+            embed_dim=hidden_size,
+            num_heads=num_attention_heads,
+            dropout=dropout,
+            batch_first=True
+        )
+        self.mono_norm = nn.LayerNorm(hidden_size)
+        
+        # Final aggregation to single glycan representation
+        self.glycan_query = nn.Parameter(torch.randn(1, 1, hidden_size) * 0.02)
+        self.glycan_attention = nn.MultiheadAttention(
+            embed_dim=hidden_size,
+            num_heads=num_attention_heads,
+            dropout=dropout,
+            batch_first=True
+        )
+        self.glycan_norm = nn.LayerNorm(hidden_size)
+    
+    def forward(
+        self,
+        hidden_states: torch.Tensor,      # (batch, seq_len, hidden)
+        residue_ids: torch.Tensor,         # (batch, seq_len) - which residue each token belongs to
+        attention_mask: torch.Tensor = None,  # (batch, seq_len)
+    ) -> torch.Tensor:
+        """
+        Pool tokens to monosaccharide level, then to glycan level.
+        
+        Returns:
+            Glycan representation: (batch, hidden_size)
+        """
+        batch_size = hidden_states.size(0)
+        device = hidden_states.device
+        
+        # Get unique residue IDs per sample (excluding -1 padding)
+        max_residues = 50  # Reasonable max for glycans
+        
+        # Pool tokens within each residue using mean pooling
+        mono_reps = torch.zeros(batch_size, max_residues, self.hidden_size, device=device)
+        mono_mask = torch.zeros(batch_size, max_residues, dtype=torch.bool, device=device)
+        
+        for b in range(batch_size):
+            unique_residues = torch.unique(residue_ids[b][residue_ids[b] >= 0])
+            for i, rid in enumerate(unique_residues):
+                if i >= max_residues:
+                    break
+                token_mask = residue_ids[b] == rid
+                if attention_mask is not None:
+                    token_mask = token_mask & (attention_mask[b] > 0)
+                if token_mask.sum() > 0:
+                    mono_reps[b, i] = hidden_states[b][token_mask].mean(dim=0)
+                    mono_mask[b, i] = True
+        
+        # Apply attention over monosaccharide representations
+        # Convert mask for attention: True = valid, need to invert for PyTorch
+        key_padding_mask = ~mono_mask  # True = ignore
+        
+        mono_out, _ = self.mono_attention(
+            mono_reps, mono_reps, mono_reps,
+            key_padding_mask=key_padding_mask
+        )
+        mono_out = self.mono_norm(mono_reps + mono_out)
+        
+        # Aggregate to single glycan representation using learned query
+        glycan_query = self.glycan_query.expand(batch_size, -1, -1)
+        glycan_out, _ = self.glycan_attention(
+            glycan_query, mono_out, mono_out,
+            key_padding_mask=key_padding_mask
+        )
+        glycan_out = self.glycan_norm(glycan_query + glycan_out)
+        
+        return glycan_out.squeeze(1)  # (batch, hidden)
+
+
+# =============================================================================
+# Improvement #2: Residue Type Embeddings
+# =============================================================================
+
+# Common monosaccharide types vocabulary
+MONOSACCHARIDE_VOCAB = {
+    '[PAD_MONO]': 0, '[UNK_MONO]': 1,
+    'Glc': 2, 'GlcNAc': 3, 'GlcA': 4, 'GlcN': 5,
+    'Gal': 6, 'GalNAc': 7, 'GalA': 8, 'GalN': 9,
+    'Man': 10, 'ManNAc': 11, 'ManA': 12, 'ManN': 13,
+    'Fuc': 14, 'Rha': 15, 'Xyl': 16, 'Ara': 17,
+    'Neu5Ac': 18, 'Neu5Gc': 19, 'Kdn': 20, 'Sia': 21,
+    'GalNAcA': 22, 'GlcNAcA': 23, 'IdoA': 24, 'GulA': 25,
+    'Rib': 26, 'Lyx': 27, 'All': 28, 'Alt': 29,
+    'Tal': 30, 'Ido': 31, 'Qui': 32, 'Oli': 33,
+    'Tyv': 34, 'Abe': 35, 'Par': 36, 'Dig': 37,
+    'Col': 38, 'Dha': 39, 'Kdo': 40, 'Hep': 41,
+    'NeuroGc': 42, 'Muramic': 43, 'LDManHep': 44, 'DDManHep': 45,
+    'Bac': 46, 'Pse': 47, 'Leg': 48, 'Aci': 49,
+    '6dTal': 50, 'Fru': 51, 'Tag': 52, 'Sor': 53,
+    'Psi': 54, 'Sed': 55, 'MurNAc': 56, 'MurNGc': 57,
+    'Api': 58, 'Erwiniose': 59, 'Yer': 60, 'Thre': 61,
+    # Add more as needed, up to ~70
+}
+
+
+class ResidueTypeEmbeddings(nn.Module):
+    """
+    Learnable embeddings for monosaccharide types.
+    
+    Instead of the model having to learn that 'a1221m' = Fucose from character patterns,
+    we explicitly add a Fucose embedding to all tokens belonging to that residue.
+    """
+    
+    def __init__(self, hidden_size: int, num_mono_types: int = 70):
+        super().__init__()
+        self.mono_embeddings = nn.Embedding(num_mono_types, hidden_size)
+        self.mono_vocab = MONOSACCHARIDE_VOCAB
+        self.hidden_size = hidden_size
+    
+    def forward(
+        self, 
+        token_embeddings: torch.Tensor,  # (batch, seq_len, hidden)
+        residue_ids: torch.Tensor,        # (batch, seq_len)
+        mono_type_ids: torch.Tensor = None,  # (batch, max_residues) - monosaccharide type per residue
+    ) -> torch.Tensor:
+        """
+        Add residue type embeddings to token embeddings.
+        
+        Args:
+            token_embeddings: Base token embeddings
+            residue_ids: Which residue each token belongs to (-1 for special tokens)
+            mono_type_ids: Monosaccharide type ID for each residue position
+            
+        Returns:
+            Enhanced embeddings with residue type information
+        """
+        if mono_type_ids is None:
+            return token_embeddings
+        
+        batch_size, seq_len, _ = token_embeddings.shape
+        enhanced = token_embeddings.clone()
+        
+        # Add mono type embedding to each token based on its residue
+        for b in range(batch_size):
+            for pos in range(seq_len):
+                rid = residue_ids[b, pos].item()
+                if rid >= 0 and rid < mono_type_ids.size(1):
+                    mono_id = mono_type_ids[b, rid]
+                    enhanced[b, pos] = enhanced[b, pos] + self.mono_embeddings(mono_id)
+        
+        return enhanced
+    
+    @staticmethod
+    def get_mono_type_id(mono_name: str) -> int:
+        """Convert monosaccharide name to type ID."""
+        return MONOSACCHARIDE_VOCAB.get(mono_name, MONOSACCHARIDE_VOCAB['[UNK_MONO]'])
+
+
+# =============================================================================
+# Improvement #4: Relative Position Encoding for Glycan Trees
+# =============================================================================
+
+class RelativePositionBias(nn.Module):
+    """
+    Compute relative position bias for attention based on residue IDs.
+    
+    Tokens in the same residue get distance 0.
+    Tokens in adjacent residues get distance ±1.
+    This helps the model understand glycan tree structure.
+    """
+    
+    def __init__(self, num_heads: int, max_distance: int = 10):
+        super().__init__()
+        self.num_heads = num_heads
+        self.max_distance = max_distance
+        
+        # Learnable bias for each relative distance (-max to +max)
+        num_distances = 2 * max_distance + 1
+        self.relative_bias = nn.Embedding(num_distances, num_heads)
+    
+    def forward(self, residue_ids: torch.Tensor) -> torch.Tensor:
+        """
+        Compute relative position bias.
+        
+        Args:
+            residue_ids: (batch, seq_len)
+            
+        Returns:
+            Bias to add to attention scores: (batch, num_heads, seq_len, seq_len)
+        """
+        # Compute pairwise residue distances
+        # (batch, seq_len, 1) - (batch, 1, seq_len) = (batch, seq_len, seq_len)
+        distance = residue_ids.unsqueeze(2) - residue_ids.unsqueeze(1)
+        
+        # Clamp to max distance range and shift to 0-indexed
+        distance_clamped = distance.clamp(-self.max_distance, self.max_distance)
+        distance_idx = distance_clamped + self.max_distance  # Now 0 to 2*max_distance
+        
+        # Look up bias: (batch, seq_len, seq_len, num_heads)
+        bias = self.relative_bias(distance_idx)
+        
+        # Transpose to (batch, num_heads, seq_len, seq_len)
+        bias = bias.permute(0, 3, 1, 2)
+        
+        return bias
+
+
+class CrossAttentionLayer(nn.Module):
+    """
+    Cross-attention layer for sequence-structure alignment.
+    
+    Allows sequence tokens to attend to structural atoms using attention masks.
+    """
+    
+    def __init__(self, config: MultimodalGlycanBERTConfig):
+        super().__init__()
+        self.num_heads = config.cross_attn_num_heads
+        self.hidden_size = config.seq_hidden_size
+        self.head_dim = self.hidden_size // self.num_heads
+        
+        assert self.hidden_size % self.num_heads == 0, "hidden_size must be divisible by num_heads"
+        
+        # Query from sequence, Key/Value from structure (VQ-VAE tokens)
+        self.query = nn.Linear(config.seq_hidden_size, self.hidden_size)
+        self.key = nn.Linear(config.struct_hidden_size, self.hidden_size)
+        self.value = nn.Linear(config.struct_hidden_size, self.hidden_size)
+        
+        self.output = nn.Linear(self.hidden_size, config.seq_hidden_size)
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+        self.layer_norm = nn.LayerNorm(config.seq_hidden_size, eps=config.layer_norm_eps)
+    
+    def forward(
+        self,
+        seq_hidden: torch.Tensor,  # (batch, seq_len, seq_hidden)
+        struct_hidden: torch.Tensor,  # (batch, struct_len, struct_hidden)
+        attention_mask: Optional[torch.Tensor] = None,  # (batch, seq_len, struct_len)
+    ) -> torch.Tensor:
+        """
+        Apply cross-attention from sequence to structure.
+        
+        Args:
+            seq_hidden: Sequence hidden states
+            struct_hidden: Structure hidden states
+            attention_mask: Boolean mask (True = can attend, False = cannot attend)
+        
+        Returns:
+            Updated sequence hidden states
+        """
+        batch_size, seq_len, _ = seq_hidden.shape
+        struct_len = struct_hidden.shape[1]
+        
+        # Project to Q, K, V
+        Q = self.query(seq_hidden)  # (batch, seq_len, hidden)
+        K = self.key(struct_hidden)  # (batch, struct_len, hidden)
+        V = self.value(struct_hidden)  # (batch, struct_len, hidden)
+        
+        # Reshape for multi-head attention
+        Q = Q.view(batch_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch, heads, seq_len, head_dim)
+        K = K.view(batch_size, struct_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch, heads, struct_len, head_dim)
+        V = V.view(batch_size, struct_len, self.num_heads, self.head_dim).transpose(1, 2)  # (batch, heads, struct_len, head_dim)
+        
+        # Compute attention scores
+        scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.head_dim)  # (batch, heads, seq_len, struct_len)
+        
+        # Apply attention mask
+        if attention_mask is not None:
+            # attention_mask: (batch, seq_len, struct_len) -> (batch, 1, seq_len, struct_len)
+            attention_mask = attention_mask.unsqueeze(1)
+            # Convert boolean mask to float: True -> 0.0, False -> -10000.0
+            attention_mask = (~attention_mask).float() * -10000.0
+            scores = scores + attention_mask
+        
+        # Softmax and dropout
+        attn_weights = torch.softmax(scores, dim=-1)  # (batch, heads, seq_len, struct_len)
+        attn_weights = self.dropout(attn_weights)
+        
+        # Apply attention to values
+        context = torch.matmul(attn_weights, V)  # (batch, heads, seq_len, head_dim)
+        
+        # Reshape back
+        context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.hidden_size)
+        
+        # Output projection
+        output = self.output(context)
+        output = self.dropout(output)
+        
+        # Residual connection + layer norm
+        output = self.layer_norm(seq_hidden + output)
+        
+        return output
+
+
+class MultimodalGlycanBERT(nn.Module):
+    """
+    Multimodal BERT for glycan representation learning (v3).
+    
+    Architecture:
+    1. Separate encoders for each modality (sequence, MS, 3D structure)
+    2. Cross-attention for sequence-structure alignment
+    3. Modality-specific MLM heads
+    4. Fusion layer for combined representation
+    """
+    
+    def __init__(self, config: MultimodalGlycanBERTConfig):
+        super().__init__()
+        self.config = config
+        
+        # ===== Sequence Encoder =====
+        seq_config = config.to_seq_config()
+        seq_config.cnn_kernel_size = config.cnn_kernel_size
+
+        if config.use_cnn_frontend:
+            print(f"✅ Enabled Convolutional Front-End (Kernel={config.cnn_kernel_size})")
+            self.seq_embeddings = ConvGlycanBERTEmbeddings(seq_config)
+        else:
+            self.seq_embeddings = GlycanBERTEmbeddings(seq_config)
+        self.seq_layers = nn.ModuleList([GlycanBERTLayer(seq_config) for _ in range(seq_config.num_hidden_layers)])
+        self.seq_mlm_head = nn.Linear(seq_config.hidden_size, seq_config.vocab_size)
+        
+        # ===== MS Encoder =====
+        ms_config = config.to_ms_config()
+        self.ms_embeddings = GlycanBERTEmbeddings(ms_config)
+        self.ms_layers = nn.ModuleList([GlycanBERTLayer(ms_config) for _ in range(ms_config.num_hidden_layers)])
+        self.ms_mlm_head = nn.Linear(ms_config.hidden_size, ms_config.vocab_size)
+        
+        # ===== Structure Encoder (VQ-VAE tokens) =====
+        if config.use_3d:
+            struct_config = config.to_struct_config()
+            self.struct_embeddings = GlycanBERTEmbeddings(struct_config)
+            self.struct_layers = nn.ModuleList([GlycanBERTLayer(struct_config) for _ in range(struct_config.num_hidden_layers)])
+            self.struct_mlm_head = nn.Linear(struct_config.hidden_size, struct_config.vocab_size)
+            
+            # Cross-attention layer (sequence → VQ-VAE structural tokens)
+            if config.use_cross_attention:
+                self.cross_attention = CrossAttentionLayer(config)
+        
+        # ===== Projection layers (align hidden sizes) =====
+        if config.ms_hidden_size != config.seq_hidden_size:
+            self.ms_projection = nn.Linear(config.ms_hidden_size, config.seq_hidden_size)
+        else:
+            self.ms_projection = nn.Identity()
+        
+        if config.use_3d and config.struct_hidden_size != config.seq_hidden_size:
+            self.struct_projection = nn.Linear(config.struct_hidden_size, config.seq_hidden_size)
+        else:
+            self.struct_projection = nn.Identity()
+        
+        # ===== Fusion Layer =====
+        # Concatenate seq + ms + struct
+        fusion_input_size = config.seq_hidden_size * (3 if config.use_3d else 2)
+        self.fusion_layer = nn.Sequential(
+            nn.Linear(fusion_input_size, config.fusion_hidden_size),
+            nn.LayerNorm(config.fusion_hidden_size, eps=config.layer_norm_eps),
+            nn.GELU(),
+            nn.Dropout(config.hidden_dropout_prob),
+            nn.Linear(config.fusion_hidden_size, config.fusion_hidden_size),
+        )
+        
+        # ===== Distance Prediction Head (Topology) =====
+        # OPTIMIZED: Project down to 128 dim first to save GPU memory
+        # (Batch, 256, 256, 768) -> (Batch, 256, 256, 128) reduces memory by 6x
+        self.dist_proj = nn.Linear(config.seq_hidden_size, 128)
+        self.distance_head = nn.Sequential(
+            nn.Linear(128, 64),
+            nn.ReLU(),
+            nn.Linear(64, 1)
+        )
+        
+        # Initialize weights
+        self.apply(self._init_weights)
+    
+    def _init_weights(self, module):
+        """Initialize weights."""
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
+            if module.padding_idx is not None:
+                module.weight.data[module.padding_idx].zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+    
+    def forward(
+        self,
+        seq_token_ids: torch.Tensor,
+        seq_attention_mask: torch.Tensor,
+        seq_residue_ids: torch.Tensor,
+        seq_branch_depths: Optional[torch.Tensor] = None,  # NEW: Branch depths
+        seq_linkage_types: Optional[torch.Tensor] = None,  # NEW: Linkage types
+        ms_token_ids: torch.Tensor = None,
+        ms_attention_mask: torch.Tensor = None,
+        has_ms: torch.Tensor = None,
+        struct_token_ids: Optional[torch.Tensor] = None,
+        struct_attention_mask: Optional[torch.Tensor] = None,
+        struct_residue_ids: Optional[torch.Tensor] = None,
+        has_3d: Optional[torch.Tensor] = None,
+        seq_labels: Optional[torch.Tensor] = None,
+        ms_labels: Optional[torch.Tensor] = None,
+        struct_labels: Optional[torch.Tensor] = None,
+        dist_labels: Optional[torch.Tensor] = None,  # NEW: Topology distance labels
+        return_dict: bool = True,
+    ) -> Dict[str, torch.Tensor]:
+        """
+        Forward pass for multimodal BERT v3.
+        
+        Args:
+            seq_token_ids: (batch_size, seq_len) - Sequence token IDs
+            seq_attention_mask: (batch_size, seq_len) - Sequence attention mask
+            seq_residue_ids: (batch_size, seq_len) - Sequence token residue IDs
+            ms_token_ids: (batch_size, ms_len) - MS token IDs
+            ms_attention_mask: (batch_size, ms_len) - MS attention mask
+            has_ms: (batch_size,) - Boolean mask for samples with MS data
+            struct_token_ids: (batch_size, struct_len) - Structure VQ-VAE token IDs (optional)
+            struct_attention_mask: (batch_size, struct_len) - Structure attention mask (optional)
+            struct_residue_ids: (batch_size, struct_len) - Structure token residue IDs (optional)
+            has_3d: (batch_size,) - Boolean mask for samples with 3D data (optional)
+            seq_labels: (batch_size, seq_len) - Masked sequence labels (optional)
+            ms_labels: (batch_size, ms_len) - Masked MS labels (optional)
+            struct_labels: (batch_size, struct_len) - Masked structure labels (optional)
+            return_dict: Whether to return dict or tuple
+        
+        Returns:
+            Dictionary containing logits, hidden states, losses, etc.
+        """
+        batch_size = seq_token_ids.shape[0]
+        device = seq_token_ids.device
+        
+        # ===== Sequence Encoder =====
+        # Pass branch_depths and linkage_types to embeddings for tree-aware encoding
+        seq_hidden = self.seq_embeddings(seq_token_ids, seq_branch_depths, seq_linkage_types)
+        for layer in self.seq_layers:
+            seq_hidden = layer(seq_hidden, seq_attention_mask)
+        
+        seq_pooled = seq_hidden[:, 0, :]  # [CLS] token
+        seq_logits = self.seq_mlm_head(seq_hidden)
+        
+        # ===== Distance Predictions (Topology) =====
+        # Compute pairwise distance predictions
+        # MEMORY OPTIMIZATION: Project to 128-dim first
+        seq_hidden_small = self.dist_proj(seq_hidden) # (batch, seq_len, 128)
+        
+        # Expand for pairwise: (batch, seq_len, 1, 128) - (batch, 1, seq_len, 128)
+        h_i = seq_hidden_small.unsqueeze(2)
+        h_j = seq_hidden_small.unsqueeze(1)
+        h_diff = torch.abs(h_i - h_j)  # (batch, seq_len, seq_len, 128) - Much smaller!
+        dist_predictions = self.distance_head(h_diff)  # (batch, seq_len, seq_len, 1)
+        
+        # ===== MS Encoder =====
+        ms_hidden = None
+        ms_pooled = None
+        ms_logits = None
+        
+        if ms_token_ids is not None:
+            ms_hidden = self.ms_embeddings(ms_token_ids)
+            for layer in self.ms_layers:
+                ms_hidden = layer(ms_hidden, ms_attention_mask)
+            
+            ms_pooled = ms_hidden[:, 0, :]  # [CLS] token
+            ms_logits = self.ms_mlm_head(ms_hidden)
+            
+            # Zero out MS representations for samples without MS data
+            if has_ms is not None:
+                has_ms_expanded = has_ms.unsqueeze(1).float()  # (batch, 1)
+                ms_pooled = ms_pooled * has_ms_expanded
+        
+        # ===== Structure Encoder =====
+        struct_pooled = None
+        struct_logits = None
+        struct_hidden = None
+        
+        if self.config.use_3d and struct_token_ids is not None:
+            struct_hidden = self.struct_embeddings(struct_token_ids)
+            for layer in self.struct_layers:
+                struct_hidden = layer(struct_hidden, struct_attention_mask)
+            
+            struct_pooled = struct_hidden[:, 0, :]  # [CLS] token
+            struct_logits = self.struct_mlm_head(struct_hidden)
+            
+            # Zero out structure representations for samples without 3D data
+            if has_3d is not None:
+                has_3d_expanded = has_3d.unsqueeze(1).float()  # (batch, 1)
+                struct_pooled = struct_pooled * has_3d_expanded
+            
+            # ===== Cross-Attention (Sequence → VQ-VAE Structural Tokens) =====
+            # Use residue-level alignment between WURCS tokens and VQ-VAE tokens
+            if self.config.use_cross_attention and struct_residue_ids is not None:
+                # Create residue-level mask
+                # WURCS token with residue_id=0 → VQ-VAE tokens with residue_id=0
+                residue_mask = create_residue_level_mask(
+                    seq_residue_ids=seq_residue_ids,
+                    struct_residue_ids=struct_residue_ids,
+                )  # (batch, N_seq, N_struct)
+                
+                # Apply cross-attention: sequence tokens attend to VQ-VAE tokens
+                seq_hidden = self.cross_attention(
+                    seq_hidden=seq_hidden,
+                    struct_hidden=struct_hidden,  # VQ-VAE token features
+                    attention_mask=residue_mask,  # Residue-based mask
+                )
+                
+                # Update seq_pooled after cross-attention
+                seq_pooled = seq_hidden[:, 0, :]
+        
+        # ===== Fusion =====
+        # Project to common hidden size
+        ms_pooled_projected = self.ms_projection(ms_pooled)
+        
+        if self.config.use_3d and struct_pooled is not None:
+            struct_pooled_projected = self.struct_projection(struct_pooled)
+            combined = torch.cat([seq_pooled, ms_pooled_projected, struct_pooled_projected], dim=-1)
+        else:
+            combined = torch.cat([seq_pooled, ms_pooled_projected], dim=-1)
+        
+        fused_repr = self.fusion_layer(combined)
+        
+        # ===== Compute Losses =====
+        total_loss = None
+        seq_loss = None
+        ms_loss = None
+        struct_loss = None
+        dist_loss = None  # NEW: Topology distance loss
+        
+        if seq_labels is not None:
+            loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+            seq_loss = loss_fct(
+                seq_logits.view(-1, self.config.seq_vocab_size),
+                seq_labels.view(-1)
+            )
+        
+        if ms_labels is not None:
+            ms_labels_masked = ms_labels.clone()
+            ms_labels_masked[~has_ms] = -100
+            # Only compute loss if there are valid labels (not all -100)
+            if (ms_labels_masked != -100).any():
+                loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+                ms_loss = loss_fct(
+                    ms_logits.view(-1, self.config.ms_total_vocab_size),
+                    ms_labels_masked.view(-1)
+                )
+            else:
+                ms_loss = torch.tensor(0.0, device=seq_token_ids.device)
+        
+        if self.config.use_3d and struct_labels is not None and struct_logits is not None:
+            struct_labels_masked = struct_labels.clone()
+            if has_3d is not None:
+                struct_labels_masked[~has_3d] = -100
+            # Only compute loss if there are valid labels (not all -100)
+            if (struct_labels_masked != -100).any():
+                loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+                struct_loss = loss_fct(
+                    struct_logits.view(-1, self.config.struct_vocab_size),
+                    struct_labels_masked.view(-1)
+                )
+            else:
+                struct_loss = torch.tensor(0.0, device=seq_token_ids.device)
+        
+        # ===== Distance Loss (Topology) =====
+        if dist_labels is not None:
+            # dist_predictions: (Batch, Seq, Seq, 1) -> (Batch, Seq, Seq)
+            preds = dist_predictions.squeeze(-1)
+            
+            # Create mask for valid distance pairs (label != -1)
+            # Also respect attention mask to avoid padding
+            valid_mask = (dist_labels != -1) & (seq_attention_mask.unsqueeze(1) * seq_attention_mask.unsqueeze(2) == 1)
+            
+            # DEBUG: Print once
+            if not hasattr(self, '_dist_debug_printed'):
+                print(f"[DIST DEBUG] dist_labels shape: {dist_labels.shape}, valid_mask.sum: {valid_mask.sum().item()}")
+                self._dist_debug_printed = True
+            
+            if valid_mask.sum() > 0:
+                # MSE loss on valid positions only
+                loss_fct = nn.MSELoss()
+                dist_loss = loss_fct(preds[valid_mask], dist_labels[valid_mask].float())
+            else:
+                dist_loss = torch.tensor(0.0, device=seq_token_ids.device)
+        else:
+            # DEBUG: dist_labels is None
+            if not hasattr(self, '_dist_none_printed'):
+                print("[DIST DEBUG] dist_labels is None!")
+                self._dist_none_printed = True
+        
+        # Weighted combination
+        losses = []
+        if seq_loss is not None:
+            losses.append(self.config.seq_loss_weight * seq_loss)
+        if ms_loss is not None:
+            losses.append(self.config.ms_loss_weight * ms_loss)
+        if struct_loss is not None:
+            losses.append(self.config.struct_loss_weight * struct_loss)
+        if dist_loss is not None:
+            losses.append(self.config.dist_loss_weight * dist_loss)
+        
+        if losses:
+            total_loss = sum(losses)
+        
+        if return_dict:
+            return {
+                'loss': total_loss,
+                'seq_loss': seq_loss,
+                'ms_loss': ms_loss,
+                'struct_loss': struct_loss,
+                'dist_loss': dist_loss,  # NEW: Topology loss
+                'seq_logits': seq_logits,
+                'ms_logits': ms_logits,
+                'struct_logits': struct_logits,
+                'dist_predictions': dist_predictions,  # NEW: Distance predictions
+                'seq_hidden': seq_hidden,
+                'ms_hidden': ms_hidden,
+                'struct_hidden': struct_hidden,
+                'seq_pooled': seq_pooled,
+                'ms_pooled': ms_pooled,
+                'struct_pooled': struct_pooled,
+                'fused_repr': fused_repr,
+            }
+        else:
+            return (total_loss, seq_logits, ms_logits, struct_logits, fused_repr)
+    
+    def get_multimodal_representation(
+        self,
+        seq_token_ids: torch.Tensor,
+        seq_attention_mask: torch.Tensor,
+        seq_residue_ids: torch.Tensor,
+        ms_token_ids: torch.Tensor,
+        ms_attention_mask: torch.Tensor,
+        has_ms: torch.Tensor,
+        struct_token_ids: Optional[torch.Tensor] = None,
+        struct_attention_mask: Optional[torch.Tensor] = None,
+        struct_residue_ids: Optional[torch.Tensor] = None,
+        has_3d: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        """Get fused multimodal representation (for inference)."""
+        outputs = self.forward(
+            seq_token_ids=seq_token_ids,
+            seq_attention_mask=seq_attention_mask,
+            seq_residue_ids=seq_residue_ids,
+            ms_token_ids=ms_token_ids,
+            ms_attention_mask=ms_attention_mask,
+            has_ms=has_ms,
+            struct_token_ids=struct_token_ids,
+            struct_attention_mask=struct_attention_mask,
+            struct_residue_ids=struct_residue_ids,
+            has_3d=has_3d,
+            return_dict=True,
+        )
+        return outputs['fused_repr']
+
+
+if __name__ == "__main__":
+    # Test the model
+    print("="*80)
+    print("Testing Multimodal GlycanBERT v3")
+    print("="*80)
+    
+    # Create config
+    config = MultimodalGlycanBERTConfig(
+        seq_vocab_size=166,
+        seq_hidden_size=768,
+        seq_num_layers=12,
+        seq_num_heads=12,
+        ms_vocab_size=242,
+        ms_hidden_size=384,
+        ms_num_layers=6,
+        ms_num_heads=6,
+        struct_vocab_size=1024,
+        struct_hidden_size=512,
+        struct_num_layers=8,
+        struct_num_heads=8,
+        use_3d=True,
+        use_cross_attention=True,
+        seq_loss_weight=0.60,
+        ms_loss_weight=0.15,
+        struct_loss_weight=0.25,
+    )
+    
+    print(f"\nConfig:")
+    print(f"  Sequence vocab: {config.seq_vocab_size}")
+    print(f"  MS vocab: {config.ms_vocab_size}")
+    print(f"  Structure vocab: {config.struct_vocab_size}")
+    print(f"  Loss weights: seq={config.seq_loss_weight}, ms={config.ms_loss_weight}, struct={config.struct_loss_weight}")
+    
+    # Create model
+    model = MultimodalGlycanBERT(config)
+    
+    # Count parameters
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    
+    print(f"\nModel Parameters:")
+    print(f"  Total: {total_params:,}")
+    print(f"  Trainable: {trainable_params:,}")
+    
+    # Test forward pass
+    print(f"\n{'='*80}")
+    print("Testing Forward Pass (with Conv front-end)")
+    print("="*80)
+    
+    batch_size = 4
+    seq_len = 128
+    ms_len = 50
+    struct_len = 40
+    
+    # Create dummy inputs
+    seq_token_ids = torch.randint(0, config.seq_vocab_size, (batch_size, seq_len))
+    seq_attention_mask = torch.ones(batch_size, seq_len)
+    # Approximate: ~5 tokens per residue
+    seq_residue_ids = torch.div(
+        torch.arange(seq_len), 5, rounding_mode="floor"
+    ).unsqueeze(0).expand(batch_size, -1)
+
+    ms_token_ids = torch.randint(config.ms_vocab_offset, config.ms_total_vocab_size, (batch_size, ms_len))
+    ms_attention_mask = torch.ones(batch_size, ms_len)
+    struct_token_ids = torch.randint(0, config.struct_vocab_size, (batch_size, struct_len))
+    struct_attention_mask = torch.ones(batch_size, struct_len)
+    # Approximate: 4 tokens per residue for VQ-VAE tokens
+    struct_residue_ids = torch.div(
+        torch.arange(struct_len), 4, rounding_mode="floor"
+    ).unsqueeze(0).expand(batch_size, -1)
+
+    has_ms = torch.tensor([True, True, False, True])
+    has_3d = torch.tensor([True, False, True, True])
+    
+    # Create labels for MLM
+    seq_labels = seq_token_ids.clone()
+    seq_labels[seq_labels != config.mask_token_id] = -100
+    ms_labels = ms_token_ids.clone()
+    ms_labels[ms_labels != config.mask_token_id] = -100
+    struct_labels = struct_token_ids.clone()
+    struct_labels[struct_labels != config.mask_token_id] = -100
+    
+    # Forward pass
+    outputs = model(
+        seq_token_ids=seq_token_ids,
+        seq_attention_mask=seq_attention_mask,
+        seq_residue_ids=seq_residue_ids,
+        ms_token_ids=ms_token_ids,
+        ms_attention_mask=ms_attention_mask,
+        has_ms=has_ms,
+        struct_token_ids=struct_token_ids,
+        struct_attention_mask=struct_attention_mask,
+        struct_residue_ids=struct_residue_ids,
+        has_3d=has_3d,
+        seq_labels=seq_labels,
+        ms_labels=ms_labels,
+        struct_labels=struct_labels,
+    )
+    
+    print(f"\nOutput shapes:")
+    print(f"  seq_logits: {outputs['seq_logits'].shape}")
+    print(f"  ms_logits: {outputs['ms_logits'].shape}")
+    print(f"  struct_logits: {outputs['struct_logits'].shape}")
+    print(f"  fused_repr: {outputs['fused_repr'].shape}")
+    
+    print(f"\nLosses:")
+    print(f"  Total loss: {outputs['loss'].item():.4f}")
+    print(f"  Sequence loss: {outputs['seq_loss'].item():.4f}")
+    print(f"  MS loss: {outputs['ms_loss'].item():.4f}")
+    print(f"  Structure loss: {outputs['struct_loss'].item():.4f}")
+    
+    print(f"\n{'='*80}")
+    print("Model Test Complete!")
+    print("="*80)

releases/2026-10-02/iar_completion/runtime_snapshot/project/writing/cluster/nature_submission/code/training/ipa_bpe_distillation.py

@@ -0,0 +1,377 @@
+#!/usr/bin/env python3
+"""
+IPA Self-Distillation for BPE Tokenized Glycan Sequences
+Iterative Pseudo-Annotation (IPA) to resolve ambiguous BPE tokens.
+"""
+
+import sys
+import torch
+import torch.nn.functional as F
+import numpy as np
+from pathlib import Path
+from typing import List, Dict, Set, Tuple
+import logging
+import pickle
+import json
+import argparse
+from copy import deepcopy
+from tqdm import tqdm
+
+# Add parent path for model imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from model.multimodal_glycan_bert_v3 import MultimodalGlycanBERT, MultimodalGlycanBERTConfig
+
+logger = logging.getLogger(__name__)
+
+
+class BPEIPADistiller:
+    """IPA Self-Distillation for BPE tokenized sequences."""
+    
+    def __init__(
+        self,
+        checkpoint_path: str,
+        vocab_path: str,
+        ambiguity_path: str,
+        device: str = "cuda",
+        threshold: float = 0.8,
+        batch_size: int = 32,
+    ):
+        self.checkpoint_path = Path(checkpoint_path)
+        self.vocab_path = Path(vocab_path)
+        self.device = torch.device(device)
+        self.threshold = threshold
+        self.batch_size = batch_size
+        
+        # Load vocabulary
+        logger.info(f"Loading BPE vocabulary from {vocab_path}")
+        with open(vocab_path, 'r') as f:
+            vocab = json.load(f)
+        
+        self.vocab = vocab
+        self.token_to_id = vocab.get('token_to_id', vocab)
+        self.id_to_token = {v: k for k, v in self.token_to_id.items()}
+        self.vocab_size = len(self.token_to_id)
+        
+        # Special tokens
+        self.pad_id = self.token_to_id.get('[PAD]', 0)
+        self.mask_id = self.token_to_id.get('[MASK]', 4)
+        self.start_id = self.token_to_id.get('[START]', 2)
+        self.end_id = self.token_to_id.get('[END]', 3)
+        
+        logger.info(f"Vocabulary size: {self.vocab_size}")
+        logger.info(f"MASK token ID: {self.mask_id}")
+        
+        # Load ambiguous token IDs
+        logger.info(f"Loading ambiguity data from {ambiguity_path}")
+        with open(ambiguity_path, 'r') as f:
+            ambig_data = json.load(f)
+        
+        self.ambiguous_token_ids = set(ambig_data.get('ambiguous_ids', []))
+        self.ambiguous_tokens = ambig_data.get('ambiguous_tokens', {})
+        
+        logger.info(f"Ambiguous BPE tokens: {len(self.ambiguous_token_ids)}")
+        
+        # Load model
+        logger.info(f"Loading model from {checkpoint_path}")
+        self.model = self._load_model()
+        self.model.to(self.device)
+        self.model.eval()
+        
+        logger.info(f"BPE IPA Distiller initialized (threshold={threshold})")
+    
+    def _load_model(self) -> MultimodalGlycanBERT:
+        """Load model from checkpoint."""
+        checkpoint = torch.load(self.checkpoint_path, map_location=self.device)
+        
+        if 'config' in checkpoint:
+            cfg = checkpoint['config']['model']
+        else:
+            cfg = {
+                'sequence': {'vocab_size': 2200, 'hidden_size': 768, 'num_hidden_layers': 12,
+                           'num_attention_heads': 12, 'max_length': 256},
+                'mass_spectrometry': {'vocab_size': 242, 'hidden_size': 384,
+                                     'num_hidden_layers': 6, 'num_attention_heads': 6, 'max_length': 150},
+                'structure_3d': {'vocab_size': 1024, 'hidden_size': 512,
+                                'num_hidden_layers': 8, 'num_attention_heads': 8, 'max_length': 200},
+                'fusion': {'fusion_hidden_size': 768, 'fusion_num_layers': 2},
+            }
+        
+        config = MultimodalGlycanBERTConfig(
+            seq_vocab_size=cfg['sequence']['vocab_size'],
+            seq_hidden_size=cfg['sequence']['hidden_size'],
+            seq_num_layers=cfg['sequence']['num_hidden_layers'],
+            seq_num_heads=cfg['sequence']['num_attention_heads'],
+            seq_max_length=cfg['sequence']['max_length'],
+            ms_vocab_size=cfg['mass_spectrometry']['vocab_size'],
+            ms_hidden_size=cfg['mass_spectrometry']['hidden_size'],
+            ms_num_layers=cfg['mass_spectrometry']['num_hidden_layers'],
+            ms_num_heads=cfg['mass_spectrometry']['num_attention_heads'],
+            ms_max_length=cfg['mass_spectrometry']['max_length'],
+            struct_vocab_size=cfg['structure_3d']['vocab_size'],
+            struct_hidden_size=cfg['structure_3d']['hidden_size'],
+            struct_num_layers=cfg['structure_3d']['num_hidden_layers'],
+            struct_num_heads=cfg['structure_3d']['num_attention_heads'],
+            struct_max_length=cfg['structure_3d']['max_length'],
+            fusion_hidden_size=cfg['fusion']['fusion_hidden_size'],
+            fusion_num_layers=cfg['fusion']['fusion_num_layers'],
+        )
+        
+        model = MultimodalGlycanBERT(config)
+        
+        if 'model_state_dict' in checkpoint:
+            model.load_state_dict(checkpoint['model_state_dict'])
+        else:
+            model.load_state_dict(checkpoint)
+        
+        return model
+    
+    def find_ambiguous_sequences(self, sequences: List[Dict]) -> Tuple[List[Dict], List[Dict], Dict]:
+        """Separate sequences into ambiguous and clean."""
+        ambiguous, clean = [], []
+        total_ambig_tokens = 0
+        
+        for seq in sequences:
+            token_ids = seq.get('token_ids', [])
+            ambig_count = sum(1 for tid in token_ids if tid in self.ambiguous_token_ids)
+            
+            if ambig_count > 0:
+                seq_copy = seq.copy()
+                seq_copy['_ambig_count'] = ambig_count
+                ambiguous.append(seq_copy)
+                total_ambig_tokens += ambig_count
+            else:
+                clean.append(seq)
+        
+        stats = {
+            'total_sequences': len(sequences),
+            'ambiguous_sequences': len(ambiguous),
+            'clean_sequences': len(clean),
+            'total_ambiguous_tokens': total_ambig_tokens,
+            'ambiguous_percentage': 100 * len(ambiguous) / len(sequences) if sequences else 0,
+        }
+        
+        return ambiguous, clean, stats
+    
+    @torch.no_grad()
+    def resolve_batch(self, sequences: List[Dict], max_length: int = 256) -> Tuple[List[Dict], int, int]:
+        """Resolve ambiguous tokens in a batch."""
+        if not sequences:
+            return [], 0, 0
+        
+        batch_token_ids, batch_attention_masks, batch_ambig_positions = [], [], []
+        
+        for seq in sequences:
+            token_ids = list(seq.get('token_ids', []))
+            ambig_positions = [i for i, tid in enumerate(token_ids) if tid in self.ambiguous_token_ids]
+            batch_ambig_positions.append(ambig_positions)
+            
+            if len(token_ids) > max_length:
+                token_ids = token_ids[:max_length]
+            
+            attention_mask = [1] * len(token_ids)
+            pad_length = max_length - len(token_ids)
+            token_ids = token_ids + [self.pad_id] * pad_length
+            attention_mask = attention_mask + [0] * pad_length
+            
+            masked_ids = token_ids.copy()
+            for pos in ambig_positions:
+                if pos < max_length:
+                    masked_ids[pos] = self.mask_id
+            
+            batch_token_ids.append(masked_ids)
+            batch_attention_masks.append(attention_mask)
+        
+        seq_tensor = torch.tensor(batch_token_ids, dtype=torch.long, device=self.device)
+        attention_tensor = torch.tensor(batch_attention_masks, dtype=torch.long, device=self.device)
+        residue_tensor = torch.zeros_like(seq_tensor)
+        
+        batch_size = seq_tensor.shape[0]
+        ms_len, struct_len = 150, 200
+        
+        outputs = self.model(
+            seq_token_ids=seq_tensor,
+            seq_attention_mask=attention_tensor,
+            seq_residue_ids=residue_tensor,
+            ms_token_ids=torch.zeros(batch_size, ms_len, dtype=torch.long, device=self.device),
+            ms_attention_mask=torch.zeros(batch_size, ms_len, dtype=torch.long, device=self.device),
+            has_ms=torch.zeros(batch_size, dtype=torch.bool, device=self.device),
+            struct_token_ids=torch.zeros(batch_size, struct_len, dtype=torch.long, device=self.device),
+            struct_attention_mask=torch.zeros(batch_size, struct_len, dtype=torch.long, device=self.device),
+            struct_residue_ids=torch.full((batch_size, struct_len), -1, dtype=torch.long, device=self.device),
+            has_3d=torch.zeros(batch_size, dtype=torch.bool, device=self.device),
+            return_dict=True,
+        )
+        
+        logits = outputs['seq_logits']
+        
+        resolved_sequences = []
+        total_resolved, total_remaining = 0, 0
+        
+        for i, seq in enumerate(sequences):
+            resolved = deepcopy(seq)
+            token_ids = list(resolved['token_ids'])
+            ambig_positions = batch_ambig_positions[i]
+            n_resolved = 0
+            
+            for pos in ambig_positions:
+                if pos >= max_length:
+                    continue
+                
+                pos_logits = logits[i, pos]
+                probs = F.softmax(pos_logits, dim=-1)
+                top_prob, top_idx = probs.max(dim=-1)
+                confidence = top_prob.item()
+                pred_id = top_idx.item()
+                
+                if (confidence >= self.threshold and 
+                    pred_id not in self.ambiguous_token_ids and
+                    pred_id != token_ids[pos]):
+                    
+                    original_token = self.id_to_token.get(token_ids[pos], '?')
+                    new_token = self.id_to_token.get(pred_id, '?')
+                    
+                    token_ids[pos] = pred_id
+                    n_resolved += 1
+                    
+                    if 'resolved_positions' not in resolved:
+                        resolved['resolved_positions'] = []
+                    resolved['resolved_positions'].append({
+                        'pos': pos, 'original': original_token,
+                        'resolved': new_token, 'confidence': confidence,
+                    })
+            
+            resolved['token_ids'] = token_ids
+            if n_resolved > 0:
+                resolved['is_distilled'] = True
+            
+            resolved_sequences.append(resolved)
+            total_resolved += n_resolved
+            n_remaining = sum(1 for tid in token_ids if tid in self.ambiguous_token_ids)
+            total_remaining += n_remaining
+        
+        return resolved_sequences, total_resolved, total_remaining
+    
+    def run_ipa(self, sequences: List[Dict], iterations: int = 3) -> Tuple[List[Dict], Dict]:
+        """Run IPA self-distillation."""
+        logger.info(f"Starting BPE IPA self-distillation (threshold={self.threshold}, iterations={iterations})")
+        
+        ambiguous, clean, initial_stats = self.find_ambiguous_sequences(sequences)
+        
+        logger.info(f"Initial: {initial_stats['ambiguous_sequences']} ambiguous sequences ({initial_stats['ambiguous_percentage']:.1f}%)")
+        logger.info(f"Total ambiguous tokens: {initial_stats['total_ambiguous_tokens']}")
+        
+        stats = {'initial': initial_stats, 'iterations': [], 'threshold': self.threshold}
+        current_sequences = ambiguous
+        
+        for iteration in range(iterations):
+            logger.info(f"\n=== Iteration {iteration + 1}/{iterations} ===")
+            
+            resolved_this_iter, total_remaining = 0, 0
+            new_sequences = []
+            
+            num_batches = (len(current_sequences) + self.batch_size - 1) // self.batch_size
+            
+            for batch_idx in tqdm(range(num_batches), desc=f"Iteration {iteration + 1}"):
+                start_idx = batch_idx * self.batch_size
+                end_idx = min(start_idx + self.batch_size, len(current_sequences))
+                batch = current_sequences[start_idx:end_idx]
+                
+                resolved_batch, n_resolved, n_remaining = self.resolve_batch(batch)
+                new_sequences.extend(resolved_batch)
+                resolved_this_iter += n_resolved
+                total_remaining += n_remaining
+            
+            current_sequences = new_sequences
+            stats['iterations'].append({
+                'iteration': iteration + 1,
+                'tokens_resolved': resolved_this_iter,
+                'tokens_remaining': total_remaining,
+            })
+            
+            logger.info(f"  Resolved {resolved_this_iter} tokens, {total_remaining} remaining")
+            
+            if resolved_this_iter == 0:
+                logger.info("  No progress, stopping early")
+                break
+        
+        all_sequences = clean + current_sequences
+        _, still_ambiguous, final_stats = self.find_ambiguous_sequences(current_sequences)
+        
+        stats['final'] = {
+            'total_sequences': len(all_sequences),
+            'fully_resolved': initial_stats['ambiguous_sequences'] - final_stats['ambiguous_sequences'],
+            'still_ambiguous': final_stats['ambiguous_sequences'],
+            'remaining_ambiguous_tokens': final_stats['total_ambiguous_tokens'],
+            'total_tokens_resolved': sum(it['tokens_resolved'] for it in stats['iterations']),
+        }
+        
+        logger.info(f"\n=== IPA Complete ===")
+        logger.info(f"Total tokens resolved: {stats['final']['total_tokens_resolved']}")
+        
+        return all_sequences, stats
+
+
+def main():
+    parser = argparse.ArgumentParser(description="BPE IPA Self-Distillation")
+    parser.add_argument("--checkpoint", type=str, required=True)
+    parser.add_argument("--sequences", type=str, required=True)
+    parser.add_argument("--vocab", type=str, required=True)
+    parser.add_argument("--ambiguity", type=str, required=True)
+    parser.add_argument("--output", type=str, required=True)
+    parser.add_argument("--threshold", type=float, default=0.8)
+    parser.add_argument("--iterations", type=int, default=3)
+    parser.add_argument("--batch-size", type=int, default=32)
+    parser.add_argument("--device", type=str, default="cuda")
+    
+    args = parser.parse_args()
+    
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+    
+    logger.info(f"Loading sequences from {args.sequences}")
+    with open(args.sequences, 'rb') as f:
+        sequences = pickle.load(f)
+    
+    if isinstance(sequences, dict):
+        sequences = list(sequences.values())
+    
+    logger.info(f"Loaded {len(sequences)} sequences")
+    
+    distiller = BPEIPADistiller(
+        checkpoint_path=args.checkpoint,
+        vocab_path=args.vocab,
+        ambiguity_path=args.ambiguity,
+        device=args.device,
+        threshold=args.threshold,
+        batch_size=args.batch_size,
+    )
+    
+    expanded_sequences, stats = distiller.run_ipa(sequences=sequences, iterations=args.iterations)
+    
+    output_path = Path(args.output)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(output_path, 'wb') as f:
+        pickle.dump(expanded_sequences, f)
+    
+    logger.info(f"Saved {len(expanded_sequences)} expanded sequences to {output_path}")
+    
+    stats_path = output_path.with_suffix('.stats.json')
+    with open(stats_path, 'w') as f:
+        json.dump(stats, f, indent=2)
+    
+    print("\n" + "="*60)
+    print("BPE IPA SELF-DISTILLATION SUMMARY")
+    print("="*60)
+    print(f"Input sequences: {stats['initial']['total_sequences']}")
+    print(f"Initially ambiguous: {stats['initial']['ambiguous_sequences']} ({stats['initial']['ambiguous_percentage']:.1f}%)")
+    print(f"Ambiguous tokens: {stats['initial']['total_ambiguous_tokens']}")
+    print(f"Threshold: {stats['threshold']}")
+    print(f"Iterations run: {len(stats['iterations'])}")
+    print(f"Tokens resolved: {stats['final']['total_tokens_resolved']}")
+    print(f"Still ambiguous: {stats['final']['still_ambiguous']}")
+    print("="*60)
+
+
+if __name__ == "__main__":
+    main()

releases/2026-10-02/iar_completion/runtime_snapshot/project/writing/glycangt_heldout_ipa_validation/cluster/heldout_ipa_eval.py

@@ -0,0 +1,962 @@
+#!/usr/bin/env python3
+"""
+Held-out IPA-style ambiguity completion evaluation for bertose_v5b_excluded.
+
+This script turns fully specified held-out glycans into synthetic ambiguity-style
+test cases by masking semantic WURCS-BPE spans, then evaluates whether the
+leakage-proof Bertose checkpoint can recover the hidden truth.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import importlib.util
+import json
+import logging
+import random
+import sys
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence
+
+import torch
+import torch.nn.functional as F
+from tqdm import tqdm
+
+
+LOGGER = logging.getLogger("heldout_ipa_eval")
+
+THIS_FILE = Path(__file__).resolve()
+ANALYSIS_ROOT = THIS_FILE.parent.parent
+WRITING_ROOT = ANALYSIS_ROOT.parent
+PROJECT_ROOT = WRITING_ROOT.parent
+TOKENIZER_UTILS_ROOT = PROJECT_ROOT / "bert_training_v4" / "downstream_tasks" / "utils"
+
+
+def first_existing_path(*candidates: Path) -> Path:
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return candidates[0]
+
+
+NATURE_CODE_ROOT = first_existing_path(
+    WRITING_ROOT / "cluster" / "nature_submission" / "code",
+    PROJECT_ROOT / "nature_submission" / "code",
+)
+DEFAULT_CHECKPOINT = first_existing_path(
+    WRITING_ROOT / "cluster" / "nature_submission" / "checkpoints" / "bertose_v5b_excluded.pt",
+    PROJECT_ROOT / "checkpoints_v5b_excluded" / "best_v5b_excluded_model.pt",
+)
+DEFAULT_VOCAB = first_existing_path(
+    WRITING_ROOT / "cluster" / "nature_submission" / "data" / "vocab" / "bpe_vocabulary_clean.json",
+    PROJECT_ROOT / "data" / "bpe_vocabulary_clean.json",
+)
+DEFAULT_AMBIGUITY = first_existing_path(
+    WRITING_ROOT / "cluster" / "nature_submission" / "data" / "vocab" / "bpe_ambiguity_tokens.json",
+    PROJECT_ROOT / "data" / "bpe_ambiguity_tokens.json",
+)
+IPA_DISTILLATION_MODULE = first_existing_path(
+    NATURE_CODE_ROOT / "training" / "ipa_bpe_distillation.py",
+    PROJECT_ROOT / "bertose" / "code" / "training" / "ipa_bpe_distillation.py",
+    PROJECT_ROOT / "bert_v5_bpe_topo" / "ipa_bpe_distillation.py",
+)
+WURCS_TOKENIZER_MODULE = first_existing_path(
+    TOKENIZER_UTILS_ROOT / "wurcs_bpe_tokenizer.py",
+    NATURE_CODE_ROOT / "tokenizer" / "wurcs_bpe_tokenizer.py",
+    PROJECT_ROOT / "bertose" / "code" / "tokenizer" / "wurcs_bpe_tokenizer.py",
+)
+
+
+def load_attr_from_module(module_path: Path, attr_name: str) -> Any:
+    spec = importlib.util.spec_from_file_location(f"heldout_dynamic_{module_path.stem}", module_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load module spec from {module_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return getattr(module, attr_name)
+
+
+BPEIPADistiller = load_attr_from_module(IPA_DISTILLATION_MODULE, "BPEIPADistiller")
+WURCSBPETokenizer = load_attr_from_module(WURCS_TOKENIZER_MODULE, "WURCSBPETokenizer")
+
+
+SPECIAL_TOKEN_NAMES = {
+    "[PAD]",
+    "[UNK]",
+    "[START]",
+    "[END]",
+    "[MASK]",
+    "[BRANCH_OPEN]",
+    "[BRANCH_CLOSE]",
+    "[LINK]",
+    "[MOD]",
+    "[RESIDUE_ERROR]",
+}
+
+
+@dataclass
+class TokenSpan:
+    start: int
+    end: int
+    unit_type: str
+    unit_text: str
+    residue_id: int
+    token_texts: List[str]
+
+    @property
+    def positions(self) -> List[int]:
+        return list(range(self.start, self.end + 1))
+
+
+@dataclass
+class EvalCase:
+    case_id: str
+    glycan_index: int
+    wurcs: str
+    wurcs_length: int
+    source_membership: str
+    source_count: str
+    unit_type: str
+    unit_text: str
+    residue_id: int
+    mask_start: int
+    mask_end: int
+    positions: List[int]
+    truth_tokens: List[str]
+    truth_token_ids: List[int]
+    masked_token_ids: List[int]
+    attention_mask: List[int]
+    residue_ids: List[int]
+    branch_depths: List[int]
+    linkage_types: List[int]
+    mask_plan: str
+
+
+class HeldoutIPAEvaluator:
+    def __init__(
+        self,
+        checkpoint: Path,
+        vocab: Path,
+        ambiguity: Path,
+        device: str,
+        threshold: float,
+        batch_size: int,
+        top_k: int,
+        max_length: int,
+    ) -> None:
+        self.distiller = BPEIPADistiller(
+            checkpoint_path=str(checkpoint),
+            vocab_path=str(vocab),
+            ambiguity_path=str(ambiguity),
+            device=device,
+            threshold=threshold,
+            batch_size=batch_size,
+        )
+        self.tokenizer = WURCSBPETokenizer(str(vocab))
+        self.device = self.distiller.device
+        self.threshold = threshold
+        self.batch_size = batch_size
+        self.top_k = top_k
+        self.max_length = max_length
+        self.model = self.distiller.model
+        self.model.eval()
+
+        self.special_token_ids = {
+            self.distiller.token_to_id[name]
+            for name in SPECIAL_TOKEN_NAMES
+            if name in self.distiller.token_to_id
+        }
+        self.invalid_prediction_ids = set(self.special_token_ids) | set(self.distiller.ambiguous_token_ids)
+
+        LOGGER.info(
+            "Evaluator ready | device=%s threshold=%.2f batch_size=%d top_k=%d max_length=%d",
+            self.device,
+            self.threshold,
+            self.batch_size,
+            self.top_k,
+            self.max_length,
+        )
+
+    def build_cases(
+        self,
+        rows: Sequence[Dict[str, str]],
+        span_types: Sequence[str],
+        selection_mode: str,
+        max_cases_per_glycan: int,
+        seed: int,
+        mask_requirements: Optional[Dict[str, int]] = None,
+    ) -> tuple[List[EvalCase], Dict[str, Any]]:
+        rng = random.Random(seed)
+        span_types = set(span_types)
+        mask_requirements = mask_requirements or {}
+
+        all_cases: List[EvalCase] = []
+        build_stats: Dict[str, Any] = {
+            "glycans_seen": len(rows),
+            "glycans_with_eligible_spans": 0,
+            "glycans_without_eligible_spans": 0,
+            "spans_seen_by_type": Counter(),
+            "spans_eligible_by_type": Counter(),
+            "spans_selected_by_type": Counter(),
+            "spans_skipped_truth_ambiguous": Counter(),
+            "spans_skipped_truncated": Counter(),
+            "glycans_skipped_mask_plan": 0,
+        }
+
+        for glycan_index, row in enumerate(tqdm(rows, desc="Building held-out cases")):
+            wurcs = row["wurcs"]
+            tokenized, spans, span_meta = self._tokenize_with_spans(wurcs)
+            for unit_type, count in span_meta["seen_by_type"].items():
+                build_stats["spans_seen_by_type"][unit_type] += count
+            for unit_type, count in span_meta["skipped_truncated_by_type"].items():
+                build_stats["spans_skipped_truncated"][unit_type] += count
+
+            eligible_spans: List[TokenSpan] = []
+            for span in spans:
+                if span.unit_type not in span_types:
+                    continue
+                if any(token_id in self.invalid_prediction_ids for token_id in self._slice(tokenized["token_ids"], span)):
+                    build_stats["spans_skipped_truth_ambiguous"][span.unit_type] += 1
+                    continue
+                build_stats["spans_eligible_by_type"][span.unit_type] += 1
+                eligible_spans.append(span)
+
+            if not eligible_spans:
+                build_stats["glycans_without_eligible_spans"] += 1
+                continue
+
+            build_stats["glycans_with_eligible_spans"] += 1
+            eligible_spans_by_type: Dict[str, List[TokenSpan]] = defaultdict(list)
+            for span in eligible_spans:
+                eligible_spans_by_type[span.unit_type].append(span)
+
+            selected_spans = self._select_spans(
+                spans=eligible_spans,
+                spans_by_type=eligible_spans_by_type,
+                selection_mode=selection_mode,
+                max_cases_per_glycan=max_cases_per_glycan,
+                rng=rng,
+                mask_requirements=mask_requirements,
+            )
+            if mask_requirements and not selected_spans:
+                build_stats["glycans_skipped_mask_plan"] += 1
+                continue
+
+            for local_idx, span in enumerate(selected_spans):
+                build_stats["spans_selected_by_type"][span.unit_type] += 1
+            if mask_requirements:
+                selected_ordered = sorted(selected_spans, key=lambda item: (item.start, item.end))
+                truth_ids: List[int] = []
+                truth_tokens: List[str] = []
+                positions: List[int] = []
+                mask_start = min(span.start for span in selected_ordered)
+                mask_end = max(span.end for span in selected_ordered)
+                masked_token_ids = list(tokenized["token_ids"])
+                unit_text = " | ".join(f"{span.unit_type}:{span.unit_text}" for span in selected_ordered)
+                mask_plan = ",".join(f"{unit_type}:{count}" for unit_type, count in sorted(mask_requirements.items()))
+                case_id = f"g{glycan_index:04d}_plan_{mask_plan.replace(',', '_').replace(':', 'x')}"
+                for span in selected_ordered:
+                    truth_ids.extend(self._slice(tokenized["token_ids"], span))
+                    truth_tokens.extend(self._slice(tokenized["tokens"], span))
+                    positions.extend(span.positions)
+                    for pos in span.positions:
+                        masked_token_ids[pos] = self.distiller.mask_id
+                all_cases.append(
+                    EvalCase(
+                        case_id=case_id,
+                        glycan_index=glycan_index,
+                        wurcs=wurcs,
+                        wurcs_length=len(wurcs),
+                        source_membership=row.get("source_membership", ""),
+                        source_count=row.get("source_count", ""),
+                        unit_type=mask_plan,
+                        unit_text=unit_text,
+                        residue_id=selected_ordered[0].residue_id,
+                        mask_start=mask_start,
+                        mask_end=mask_end,
+                        positions=positions,
+                        truth_tokens=truth_tokens,
+                        truth_token_ids=truth_ids,
+                        masked_token_ids=masked_token_ids,
+                        attention_mask=list(tokenized["attention_mask"]),
+                        residue_ids=list(tokenized["residue_ids"]),
+                        branch_depths=list(tokenized["branch_depths"]),
+                        linkage_types=list(tokenized["linkage_types"]),
+                        mask_plan=mask_plan,
+                    )
+                )
+            else:
+                for local_idx, span in enumerate(selected_spans):
+                    truth_ids = self._slice(tokenized["token_ids"], span)
+                    truth_tokens = self._slice(tokenized["tokens"], span)
+                    masked_token_ids = list(tokenized["token_ids"])
+                    for pos in span.positions:
+                        masked_token_ids[pos] = self.distiller.mask_id
+
+                    all_cases.append(
+                        EvalCase(
+                            case_id=f"g{glycan_index:04d}_s{local_idx:02d}_{span.unit_type}_{span.start}_{span.end}",
+                            glycan_index=glycan_index,
+                            wurcs=wurcs,
+                            wurcs_length=len(wurcs),
+                            source_membership=row.get("source_membership", ""),
+                            source_count=row.get("source_count", ""),
+                            unit_type=span.unit_type,
+                            unit_text=span.unit_text,
+                            residue_id=span.residue_id,
+                            mask_start=span.start,
+                            mask_end=span.end,
+                            positions=span.positions,
+                            truth_tokens=truth_tokens,
+                            truth_token_ids=truth_ids,
+                            masked_token_ids=masked_token_ids,
+                            attention_mask=list(tokenized["attention_mask"]),
+                            residue_ids=list(tokenized["residue_ids"]),
+                            branch_depths=list(tokenized["branch_depths"]),
+                            linkage_types=list(tokenized["linkage_types"]),
+                            mask_plan=f"{span.unit_type}:1",
+                        )
+                    )
+
+        build_stats["num_cases"] = len(all_cases)
+        build_stats["num_masked_positions"] = sum(len(case.positions) for case in all_cases)
+        build_stats["avg_masked_positions_per_case"] = (
+            build_stats["num_masked_positions"] / len(all_cases) if all_cases else 0.0
+        )
+        build_stats["span_types"] = sorted(span_types)
+        return all_cases, self._json_ready(build_stats)
+
+    def evaluate_cases(self, cases: Sequence[EvalCase], iterations: int) -> tuple[List[Dict[str, Any]], Dict[str, Any]]:
+        if not cases:
+            return [], {}
+
+        results: List[Dict[str, Any]] = []
+        num_batches = (len(cases) + self.batch_size - 1) // self.batch_size
+
+        for batch_idx in tqdm(range(num_batches), desc="Evaluating held-out cases"):
+            start = batch_idx * self.batch_size
+            end = min(start + self.batch_size, len(cases))
+            batch_cases = list(cases[start:end])
+            batch_results = self._evaluate_batch(batch_cases=batch_cases, iterations=iterations)
+            results.extend(batch_results)
+
+        summary = self._summarize_results(results=results, iterations=iterations)
+        return results, summary
+
+    def _evaluate_batch(self, batch_cases: Sequence[EvalCase], iterations: int) -> List[Dict[str, Any]]:
+        current_token_ids = [list(case.masked_token_ids) for case in batch_cases]
+        unresolved_positions = [set(case.positions) for case in batch_cases]
+        initial_position_details: List[List[Dict[str, Any]]] = [[] for _ in batch_cases]
+        accepted_updates_per_case: List[List[Dict[str, Any]]] = [[] for _ in batch_cases]
+
+        for iteration_idx in range(iterations):
+            logits = self._forward_logits(batch_cases=batch_cases, current_token_ids=current_token_ids)
+
+            progress_this_round = 0
+            for case_idx, case in enumerate(batch_cases):
+                if not unresolved_positions[case_idx]:
+                    continue
+
+                iteration_updates: List[Dict[str, Any]] = []
+                for local_pos_idx, pos in enumerate(case.positions):
+                    position_logits = logits[case_idx, pos]
+                    probs = F.softmax(position_logits, dim=-1)
+                    top_probs, top_ids = torch.topk(probs, k=self.top_k)
+
+                    top_tokens = [self.distiller.id_to_token[int(token_id)] for token_id in top_ids.tolist()]
+                    detail = {
+                        "position": pos,
+                        "truth_token": case.truth_tokens[local_pos_idx],
+                        "truth_token_id": case.truth_token_ids[local_pos_idx],
+                        "top_ids": [int(token_id) for token_id in top_ids.tolist()],
+                        "top_tokens": top_tokens,
+                        "top_probs": [float(prob) for prob in top_probs.tolist()],
+                        "top1_id": int(top_ids[0].item()),
+                        "top1_token": top_tokens[0],
+                        "top1_prob": float(top_probs[0].item()),
+                        "top1_correct": int(top_ids[0].item()) == case.truth_token_ids[local_pos_idx],
+                        "top5_contains_truth": case.truth_token_ids[local_pos_idx] in {
+                            int(token_id) for token_id in top_ids.tolist()
+                        },
+                    }
+
+                    if iteration_idx == 0:
+                        initial_position_details[case_idx].append(detail)
+
+                    if pos not in unresolved_positions[case_idx]:
+                        continue
+
+                    pred_id = detail["top1_id"]
+                    pred_prob = detail["top1_prob"]
+                    if pred_prob < self.threshold:
+                        continue
+                    if pred_id in self.invalid_prediction_ids:
+                        continue
+
+                    current_token_ids[case_idx][pos] = pred_id
+                    unresolved_positions[case_idx].remove(pos)
+                    progress_this_round += 1
+                    iteration_updates.append(
+                        {
+                            "iteration": iteration_idx + 1,
+                            "position": pos,
+                            "predicted_id": pred_id,
+                            "predicted_token": detail["top1_token"],
+                            "confidence": pred_prob,
+                            "correct": pred_id == detail["truth_token_id"],
+                        }
+                    )
+
+                if iteration_updates:
+                    accepted_updates_per_case[case_idx].extend(iteration_updates)
+
+            if progress_this_round == 0:
+                LOGGER.info("Stopping early after iteration %d because no new positions were accepted", iteration_idx + 1)
+                break
+
+        batch_results: List[Dict[str, Any]] = []
+        for case_idx, case in enumerate(batch_cases):
+            final_token_ids = [current_token_ids[case_idx][pos] for pos in case.positions]
+            final_tokens = [self.distiller.id_to_token[token_id] for token_id in final_token_ids]
+            final_correct_flags = [
+                final_token_ids[pos_idx] == case.truth_token_ids[pos_idx]
+                for pos_idx in range(len(case.positions))
+            ]
+            resolved_flags = [
+                case.positions[pos_idx] not in unresolved_positions[case_idx]
+                for pos_idx in range(len(case.positions))
+            ]
+            initial_details = initial_position_details[case_idx]
+
+            batch_results.append(
+                {
+                    "case_id": case.case_id,
+                    "glycan_index": case.glycan_index,
+                    "wurcs": case.wurcs,
+                    "wurcs_length": case.wurcs_length,
+                    "source_membership": case.source_membership,
+                    "source_count": case.source_count,
+                    "unit_type": case.unit_type,
+                    "mask_plan": case.mask_plan,
+                    "unit_text": case.unit_text,
+                    "residue_id": case.residue_id,
+                    "positions": case.positions,
+                    "mask_start": case.mask_start,
+                    "mask_end": case.mask_end,
+                    "num_masked_positions": len(case.positions),
+                    "truth_tokens": case.truth_tokens,
+                    "truth_token_ids": case.truth_token_ids,
+                    "initial_position_details": initial_details,
+                    "accepted_updates": accepted_updates_per_case[case_idx],
+                    "final_tokens": final_tokens,
+                    "final_token_ids": final_token_ids,
+                    "resolved_flags": resolved_flags,
+                    "final_correct_flags": final_correct_flags,
+                    "initial_top1_correct_count": sum(1 for item in initial_details if item["top1_correct"]),
+                    "initial_top5_correct_count": sum(1 for item in initial_details if item["top5_contains_truth"]),
+                    "resolved_count": sum(1 for flag in resolved_flags if flag),
+                    "final_correct_count": sum(1 for flag in final_correct_flags if flag),
+                    "initial_span_exact_top1": all(item["top1_correct"] for item in initial_details) if initial_details else False,
+                    "initial_span_exact_top5": all(item["top5_contains_truth"] for item in initial_details) if initial_details else False,
+                    "iterative_span_exact": all(final_correct_flags) if final_correct_flags else False,
+                    "iterations_used": max(
+                        (update["iteration"] for update in accepted_updates_per_case[case_idx]),
+                        default=0,
+                    ),
+                }
+            )
+
+        return batch_results
+
+    def _forward_logits(
+        self,
+        batch_cases: Sequence[EvalCase],
+        current_token_ids: Sequence[List[int]],
+    ) -> torch.Tensor:
+        batch_size = len(batch_cases)
+
+        seq_token_ids = torch.tensor(current_token_ids, dtype=torch.long, device=self.device)
+        seq_attention_mask = torch.tensor(
+            [case.attention_mask for case in batch_cases], dtype=torch.long, device=self.device
+        )
+        seq_residue_ids = torch.tensor(
+            [case.residue_ids for case in batch_cases], dtype=torch.long, device=self.device
+        )
+        seq_branch_depths = torch.tensor(
+            [case.branch_depths for case in batch_cases], dtype=torch.long, device=self.device
+        )
+        seq_linkage_types = torch.tensor(
+            [case.linkage_types for case in batch_cases], dtype=torch.long, device=self.device
+        )
+
+        ms_len = 150
+        struct_len = 200
+        outputs = self.model(
+            seq_token_ids=seq_token_ids,
+            seq_attention_mask=seq_attention_mask,
+            seq_residue_ids=seq_residue_ids,
+            seq_branch_depths=seq_branch_depths,
+            seq_linkage_types=seq_linkage_types,
+            ms_token_ids=torch.zeros(batch_size, ms_len, dtype=torch.long, device=self.device),
+            ms_attention_mask=torch.zeros(batch_size, ms_len, dtype=torch.long, device=self.device),
+            has_ms=torch.zeros(batch_size, dtype=torch.bool, device=self.device),
+            struct_token_ids=torch.zeros(batch_size, struct_len, dtype=torch.long, device=self.device),
+            struct_attention_mask=torch.zeros(batch_size, struct_len, dtype=torch.long, device=self.device),
+            struct_residue_ids=torch.full((batch_size, struct_len), -1, dtype=torch.long, device=self.device),
+            has_3d=torch.zeros(batch_size, dtype=torch.bool, device=self.device),
+            return_dict=True,
+        )
+        return outputs["seq_logits"]
+
+    def _tokenize_with_spans(self, wurcs: str) -> tuple[Dict[str, Any], List[TokenSpan], Dict[str, Counter]]:
+        tokenized = self.tokenizer.tokenize(wurcs, max_length=self.max_length)
+        unpadded_tokens = tokenized["tokens"][: tokenized["length"]]
+        units = self.tokenizer.pre_tokenizer.pre_tokenize(wurcs)
+
+        spans: List[TokenSpan] = []
+        raw_cursor = 0
+        span_meta = {
+            "seen_by_type": Counter(),
+            "skipped_truncated_by_type": Counter(),
+        }
+
+        for unit in units:
+            unit_tokens = [unit["text"]] if unit["type"] == "special" else self.tokenizer.apply_bpe(unit["text"])
+            span_start = raw_cursor
+            span_end = raw_cursor + len(unit_tokens) - 1
+            raw_cursor += len(unit_tokens)
+
+            if unit["type"] != "special":
+                span_meta["seen_by_type"][unit["type"]] += 1
+
+            if unit["type"] == "special":
+                continue
+            if span_end >= len(unpadded_tokens):
+                span_meta["skipped_truncated_by_type"][unit["type"]] += 1
+                continue
+            if unpadded_tokens[span_start : span_end + 1] != unit_tokens:
+                span_meta["skipped_truncated_by_type"][unit["type"]] += 1
+                continue
+
+            spans.append(
+                TokenSpan(
+                    start=span_start,
+                    end=span_end,
+                    unit_type=unit["type"],
+                    unit_text=unit["text"],
+                    residue_id=unit["residue_id"],
+                    token_texts=unit_tokens,
+                )
+            )
+
+        return tokenized, spans, span_meta
+
+    @staticmethod
+    def _slice(values: Sequence[Any], span: TokenSpan) -> List[Any]:
+        return list(values[span.start : span.end + 1])
+
+    @staticmethod
+    def _select_spans(
+        spans: Sequence[TokenSpan],
+        spans_by_type: Dict[str, List[TokenSpan]],
+        selection_mode: str,
+        max_cases_per_glycan: int,
+        rng: random.Random,
+        mask_requirements: Optional[Dict[str, int]] = None,
+    ) -> List[TokenSpan]:
+        ordered = sorted(spans, key=lambda item: (item.start, item.end))
+        mask_requirements = mask_requirements or {}
+        if mask_requirements:
+            selected: List[TokenSpan] = []
+            for unit_type, count in sorted(mask_requirements.items()):
+                unit_spans = sorted(spans_by_type.get(unit_type, []), key=lambda item: (item.start, item.end))
+                if len(unit_spans) < count:
+                    return []
+                if selection_mode == "all":
+                    chosen = unit_spans[:count]
+                elif selection_mode == "first":
+                    chosen = unit_spans[:count]
+                elif selection_mode == "sample":
+                    chosen = sorted(rng.sample(unit_spans, count), key=lambda item: (item.start, item.end))
+                else:
+                    raise ValueError(f"Unsupported selection mode: {selection_mode}")
+                selected.extend(chosen)
+            return sorted(selected, key=lambda item: (item.start, item.end))
+        if selection_mode == "all":
+            return ordered
+        if selection_mode == "first":
+            return ordered[:max_cases_per_glycan]
+        if selection_mode == "sample":
+            k = min(max_cases_per_glycan, len(ordered))
+            return sorted(rng.sample(ordered, k), key=lambda item: (item.start, item.end))
+        raise ValueError(f"Unsupported selection mode: {selection_mode}")
+
+    @staticmethod
+    def _json_ready(obj: Any) -> Any:
+        if isinstance(obj, Counter):
+            return dict(obj)
+        if isinstance(obj, defaultdict):
+            return {key: HeldoutIPAEvaluator._json_ready(value) for key, value in obj.items()}
+        if isinstance(obj, dict):
+            return {key: HeldoutIPAEvaluator._json_ready(value) for key, value in obj.items()}
+        if isinstance(obj, list):
+            return [HeldoutIPAEvaluator._json_ready(value) for value in obj]
+        return obj
+
+    def _summarize_results(self, results: Sequence[Dict[str, Any]], iterations: int) -> Dict[str, Any]:
+        total_cases = len(results)
+        total_positions = sum(result["num_masked_positions"] for result in results)
+        if total_cases == 0 or total_positions == 0:
+            return {}
+
+        overall = self._aggregate_slice(results)
+        by_unit_type = {
+            unit_type: self._aggregate_slice([result for result in results if result["unit_type"] == unit_type])
+            for unit_type in sorted({result["unit_type"] for result in results})
+        }
+
+        return {
+            "num_cases": total_cases,
+            "num_masked_positions": total_positions,
+            "iterations_requested": iterations,
+            "threshold": self.threshold,
+            "top_k": self.top_k,
+            "overall": overall,
+            "by_unit_type": by_unit_type,
+        }
+
+    @staticmethod
+    def _aggregate_slice(results: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+        total_cases = len(results)
+        total_positions = sum(result["num_masked_positions"] for result in results)
+        initial_top1_correct = sum(result["initial_top1_correct_count"] for result in results)
+        initial_top5_correct = sum(result["initial_top5_correct_count"] for result in results)
+        resolved_count = sum(result["resolved_count"] for result in results)
+        final_correct_count = sum(result["final_correct_count"] for result in results)
+
+        return {
+            "num_cases": total_cases,
+            "num_masked_positions": total_positions,
+            "avg_masked_positions_per_case": total_positions / total_cases if total_cases else 0.0,
+            "initial_top1_token_accuracy": initial_top1_correct / total_positions if total_positions else 0.0,
+            "initial_top5_token_accuracy": initial_top5_correct / total_positions if total_positions else 0.0,
+            "initial_exact_span_accuracy_top1": (
+                sum(1 for result in results if result["initial_span_exact_top1"]) / total_cases if total_cases else 0.0
+            ),
+            "initial_exact_span_accuracy_top5": (
+                sum(1 for result in results if result["initial_span_exact_top5"]) / total_cases if total_cases else 0.0
+            ),
+            "iterative_resolved_fraction": resolved_count / total_positions if total_positions else 0.0,
+            "iterative_accuracy_among_resolved": final_correct_count / resolved_count if resolved_count else 0.0,
+            "iterative_final_token_accuracy": final_correct_count / total_positions if total_positions else 0.0,
+            "iterative_exact_span_accuracy": (
+                sum(1 for result in results if result["iterative_span_exact"]) / total_cases if total_cases else 0.0
+            ),
+            "avg_iterations_used_per_case": (
+                sum(result["iterations_used"] for result in results) / total_cases if total_cases else 0.0
+            ),
+        }
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Held-out IPA-style evaluation for bertose_v5b_excluded")
+    parser.add_argument(
+        "--input-csv",
+        type=Path,
+        default=ANALYSIS_ROOT / "data" / "benchmark_exclusion_1392_unseen_to_bertose_v5b_excluded.csv",
+    )
+    parser.add_argument(
+        "--checkpoint",
+        type=Path,
+        default=DEFAULT_CHECKPOINT,
+    )
+    parser.add_argument(
+        "--vocab",
+        type=Path,
+        default=DEFAULT_VOCAB,
+    )
+    parser.add_argument(
+        "--ambiguity",
+        type=Path,
+        default=DEFAULT_AMBIGUITY,
+    )
+    parser.add_argument("--output-dir", type=Path, default=ANALYSIS_ROOT / "outputs")
+    parser.add_argument("--run-name", type=str, default="benchmark1392_pilot")
+    parser.add_argument("--device", type=str, default="cuda")
+    parser.add_argument("--batch-size", type=int, default=32)
+    parser.add_argument("--iterations", type=int, default=3)
+    parser.add_argument("--threshold", type=float, default=0.80)
+    parser.add_argument("--top-k", type=int, default=5)
+    parser.add_argument("--max-length", type=int, default=256)
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--shuffle", action="store_true")
+    parser.add_argument("--selection-mode", choices=["sample", "first", "all"], default="sample")
+    parser.add_argument("--max-cases-per-glycan", type=int, default=1)
+    parser.add_argument("--span-types", type=str, default="residue,linkage")
+    parser.add_argument("--mask-plan", type=str, default="")
+    parser.add_argument("--log-level", type=str, default="INFO")
+    return parser.parse_args()
+
+
+def parse_mask_plan(mask_plan: str) -> Dict[str, int]:
+    mask_plan = mask_plan.strip()
+    if not mask_plan:
+        return {}
+    requirements: Dict[str, int] = {}
+    for item in mask_plan.split(","):
+        part = item.strip()
+        if not part:
+            continue
+        if ":" not in part:
+            raise ValueError(f"Invalid mask-plan item: {part}")
+        unit_type, count_str = part.split(":", 1)
+        unit_type = unit_type.strip()
+        count = int(count_str.strip())
+        if count <= 0:
+            raise ValueError(f"Mask-plan counts must be positive: {part}")
+        requirements[unit_type] = count
+    return requirements
+
+
+def setup_logging(level: str) -> None:
+    logging.basicConfig(
+        level=getattr(logging, level.upper(), logging.INFO),
+        format="%(asctime)s - %(levelname)s - %(message)s",
+    )
+
+
+def load_rows(input_csv: Path, limit: Optional[int], shuffle: bool, seed: int) -> List[Dict[str, str]]:
+    with input_csv.open() as handle:
+        rows = list(csv.DictReader(handle))
+
+    if "in_reconstructed_leakage_proof_pretrain" in rows[0]:
+        not_unseen = [
+            row["wurcs"]
+            for row in rows
+            if row["in_reconstructed_leakage_proof_pretrain"].strip().lower() != "false"
+        ]
+        if not_unseen:
+            raise ValueError(
+                f"Input CSV contains {len(not_unseen)} glycans that are not marked unseen to the leakage-proof model"
+            )
+
+    if shuffle:
+        rng = random.Random(seed)
+        rng.shuffle(rows)
+
+    if limit is not None:
+        rows = rows[:limit]
+
+    return rows
+
+
+def write_json(path: Path, payload: Dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2))
+
+
+def write_jsonl(path: Path, rows: Iterable[Dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w") as handle:
+        for row in rows:
+            handle.write(json.dumps(row) + "\n")
+
+
+def write_case_csv(path: Path, rows: Sequence[Dict[str, Any]]) -> None:
+    flat_rows = []
+    for row in rows:
+        flat_rows.append(
+            {
+                "case_id": row["case_id"],
+                "glycan_index": row["glycan_index"],
+                "unit_type": row["unit_type"],
+                "mask_plan": row.get("mask_plan", row["unit_type"]),
+                "unit_text": row["unit_text"],
+                "mask_start": row["mask_start"],
+                "mask_end": row["mask_end"],
+                "num_masked_positions": row["num_masked_positions"],
+                "initial_top1_correct_count": row["initial_top1_correct_count"],
+                "initial_top5_correct_count": row["initial_top5_correct_count"],
+                "resolved_count": row["resolved_count"],
+                "final_correct_count": row["final_correct_count"],
+                "initial_span_exact_top1": row["initial_span_exact_top1"],
+                "initial_span_exact_top5": row["initial_span_exact_top5"],
+                "iterative_span_exact": row["iterative_span_exact"],
+                "iterations_used": row["iterations_used"],
+                "truth_tokens": "|".join(row["truth_tokens"]),
+                "final_tokens": "|".join(row["final_tokens"]),
+                "wurcs": row["wurcs"],
+            }
+        )
+
+    fieldnames = list(flat_rows[0].keys()) if flat_rows else [
+        "case_id",
+        "glycan_index",
+        "unit_type",
+        "mask_plan",
+        "unit_text",
+        "mask_start",
+        "mask_end",
+        "num_masked_positions",
+        "initial_top1_correct_count",
+        "initial_top5_correct_count",
+        "resolved_count",
+        "final_correct_count",
+        "initial_span_exact_top1",
+        "initial_span_exact_top5",
+        "iterative_span_exact",
+        "iterations_used",
+        "truth_tokens",
+        "final_tokens",
+        "wurcs",
+    ]
+
+    with path.open("w", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(flat_rows)
+
+
+def write_summary_markdown(
+    path: Path,
+    *,
+    args: argparse.Namespace,
+    input_rows: Sequence[Dict[str, str]],
+    build_stats: Dict[str, Any],
+    summary: Dict[str, Any],
+) -> None:
+    overall = summary.get("overall", {})
+    by_unit_type = summary.get("by_unit_type", {})
+
+    lines = [
+        "# Held-out IPA Evaluation Summary",
+        "",
+        "## Run",
+        "",
+        f"- run_name: `{args.run_name}`",
+        f"- input_csv: `{args.input_csv}`",
+        f"- checkpoint: `{args.checkpoint}`",
+        f"- vocab: `{args.vocab}`",
+        f"- ambiguity: `{args.ambiguity}`",
+        f"- device: `{args.device}`",
+        f"- threshold: `{args.threshold}`",
+        f"- iterations: `{args.iterations}`",
+        f"- top_k: `{args.top_k}`",
+        f"- selection_mode: `{args.selection_mode}`",
+        f"- max_cases_per_glycan: `{args.max_cases_per_glycan}`",
+        f"- span_types: `{args.span_types}`",
+        f"- mask_plan: `{args.mask_plan or 'single-span default'}`",
+        "",
+        "## Dataset",
+        "",
+        f"- glycans_loaded: `{len(input_rows)}`",
+        f"- cases_built: `{build_stats.get('num_cases', 0)}`",
+        f"- masked_positions: `{build_stats.get('num_masked_positions', 0)}`",
+        f"- glycans_with_eligible_spans: `{build_stats.get('glycans_with_eligible_spans', 0)}`",
+        f"- glycans_without_eligible_spans: `{build_stats.get('glycans_without_eligible_spans', 0)}`",
+        f"- glycans_skipped_mask_plan: `{build_stats.get('glycans_skipped_mask_plan', 0)}`",
+        "",
+        "## Overall Metrics",
+        "",
+    ]
+
+    metric_order = [
+        "initial_top1_token_accuracy",
+        "initial_top5_token_accuracy",
+        "initial_exact_span_accuracy_top1",
+        "initial_exact_span_accuracy_top5",
+        "iterative_resolved_fraction",
+        "iterative_accuracy_among_resolved",
+        "iterative_final_token_accuracy",
+        "iterative_exact_span_accuracy",
+        "avg_iterations_used_per_case",
+    ]
+    for metric in metric_order:
+        value = overall.get(metric)
+        if value is not None:
+            lines.append(f"- {metric}: `{value:.4f}`")
+
+    if by_unit_type:
+        lines.extend(["", "## By Evaluation Group", ""])
+        for unit_type, unit_metrics in by_unit_type.items():
+            lines.append(f"### {unit_type}")
+            lines.append("")
+            for metric in metric_order:
+                value = unit_metrics.get(metric)
+                if value is not None:
+                    lines.append(f"- {metric}: `{value:.4f}`")
+            lines.append("")
+
+    path.write_text("\n".join(lines).rstrip() + "\n")
+
+
+def main() -> None:
+    args = parse_args()
+    setup_logging(args.log_level)
+
+    LOGGER.info("Loading held-out rows from %s", args.input_csv)
+    rows = load_rows(input_csv=args.input_csv, limit=args.limit, shuffle=args.shuffle, seed=args.seed)
+    LOGGER.info("Loaded %d glycans", len(rows))
+
+    span_types = [item.strip() for item in args.span_types.split(",") if item.strip()]
+    mask_requirements = parse_mask_plan(args.mask_plan)
+    if mask_requirements:
+        span_types = sorted(set(span_types) | set(mask_requirements))
+    evaluator = HeldoutIPAEvaluator(
+        checkpoint=args.checkpoint,
+        vocab=args.vocab,
+        ambiguity=args.ambiguity,
+        device=args.device,
+        threshold=args.threshold,
+        batch_size=args.batch_size,
+        top_k=args.top_k,
+        max_length=args.max_length,
+    )
+
+    cases, build_stats = evaluator.build_cases(
+        rows=rows,
+        span_types=span_types,
+        selection_mode=args.selection_mode,
+        max_cases_per_glycan=args.max_cases_per_glycan,
+        seed=args.seed,
+        mask_requirements=mask_requirements,
+    )
+    LOGGER.info(
+        "Built %d evaluation cases across %d masked positions",
+        build_stats.get("num_cases", 0),
+        build_stats.get("num_masked_positions", 0),
+    )
+
+    results, summary = evaluator.evaluate_cases(cases=cases, iterations=args.iterations)
+
+    run_dir = args.output_dir / args.run_name
+    run_dir.mkdir(parents=True, exist_ok=True)
+    write_json(run_dir / "build_stats.json", build_stats)
+    write_json(run_dir / "summary.json", summary)
+    write_jsonl(run_dir / "case_details.jsonl", results)
+    write_case_csv(run_dir / "case_results.csv", results)
+    write_summary_markdown(
+        run_dir / "summary.md",
+        args=args,
+        input_rows=rows,
+        build_stats=build_stats,
+        summary=summary,
+    )
+
+    LOGGER.info("Saved outputs under %s", run_dir)
+    if summary:
+        LOGGER.info(
+            "Overall top1=%.4f top5=%.4f iterative_final=%.4f span_exact=%.4f",
+            summary["overall"]["initial_top1_token_accuracy"],
+            summary["overall"]["initial_top5_token_accuracy"],
+            summary["overall"]["iterative_final_token_accuracy"],
+            summary["overall"]["iterative_exact_span_accuracy"],
+        )
+
+
+if __name__ == "__main__":
+    main()

releases/2026-10-02/iar_completion/runtime_snapshot/schema/classify.py

@@ -0,0 +1,78 @@
+"""Definitive classification of '|' in WURCS LIN + residue-definition sections."""
+import re, collections, json, sys
+sys.path.insert(0,'.')
+from pipelib import (split_sections, _TopLevelBracket, parse_record, ALT_GROUP_RE,
+                     SIDE_RE, node_index)
+
+TOKEN_RE = re.compile(r"[A-Za-z]+[0-9?]+")
+
+def groups_in(entry):
+    return [m.group(0) for m in ALT_GROUP_RE.finditer(entry)]
+
+def group_kind(g):
+    members = g.split("|")
+    parsed = []
+    for m in members:
+        mm = SIDE_RE.match(m)
+        if not mm: return None
+        parsed.append((mm.group(1), mm.group(2)))
+    res = [p[0] for p in parsed]; pos = [p[1] for p in parsed]
+    ures, upos = set(res), set(pos)
+    if len(ures) == 1 and len(upos) > 1:
+        return ("P_ALT_UNK" if "?" in upos else "P_ALT"), parsed
+    if len(upos) == 1 and len(ures) > 1:
+        return ("R_ALT_UNK" if "?" in upos else "R_ALT"), parsed
+    if len(ures) == 1 and len(upos) == 1:
+        return "DEGENERATE", parsed
+    return "JOINT_ALT", parsed
+
+# entry-level shape: is it a plain 2-sided linkage with no repeat furniture?
+PLAIN_LINK = re.compile(r"^([A-Za-z0-9?|]+)-([A-Za-z0-9?|]+)$")
+
+def classify_entry(entry, rec):
+    """Returns dict describing one pipe-bearing LIN entry."""
+    out = {}
+    out["repeat"] = ("{" in entry) or ("}" in entry)
+    out["tilde"] = "~" in entry
+    out["substituent"] = "*" in entry
+    gs = groups_in(entry)
+    kinds = []
+    for g in gs:
+        k = group_kind(g)
+        kinds.append(k[0] if k else "UNPARSED")
+    out["groups"] = gs
+    out["kinds"] = kinds
+    m = PLAIN_LINK.match(entry)
+    out["plain_link"] = bool(m)
+    out["r205"] = False
+    out["r205_detail"] = None
+    if m and not out["repeat"] and not out["tilde"] and not out["substituent"]:
+        L, R = m.group(1), m.group(2)
+        for altside, fixside in ((L, R), (R, L)):
+            if "|" not in altside or "|" in fixside:
+                continue
+            k = group_kind(altside)
+            if not k or k[0] != "P_ALT":
+                continue
+            fm = SIDE_RE.match(fixside)
+            if not fm or fm.group(2) == "?":
+                continue
+            dres, dpos = fm.group(1), int(fm.group(2))
+            ares = k[1][0][0]
+            apos = sorted(int(p) for _, p in k[1])
+            try:
+                di = node_index(dres) - 1; ai = node_index(ares) - 1
+            except ValueError:
+                continue
+            if not (0 <= di < rec["nres"] and 0 <= ai < rec["nres"]):
+                continue
+            danom = rec["anom"][di]; aanom = rec["anom"][ai]
+            donor_ok = (danom is not None and danom == dpos)
+            acceptor_ok = (aanom is None) or (aanom not in apos)
+            if donor_ok and acceptor_ok:
+                out["r205"] = True
+                out["r205_detail"] = dict(donor_skel=rec["skel"][di], donor_pos=dpos,
+                                          acceptor_skel=rec["skel"][ai], alts=apos,
+                                          acceptor_subs=sorted(rec["subs"][ai]))
+                break
+    return out

releases/2026-10-02/iar_completion/runtime_snapshot/schema/pipelib.py

@@ -0,0 +1,119 @@
+"""Shared WURCS '|' classification library.  Frozen-parser-faithful where it matters."""
+import re
+
+WURCS_RES_INDEX_ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+def node_index(label):
+    base = len(WURCS_RES_INDEX_ALPHABET)
+    value = 0
+    for ch in label:
+        d = WURCS_RES_INDEX_ALPHABET.index(ch) + 1  # raises ValueError
+        value = value * base + d
+    return value
+
+def split_sections(wurcs):
+    """Frozen A5WURCSPreTokenizer._split_wurcs_sections semantics."""
+    if wurcs.startswith("WURCS="):
+        body = wurcs[6:]
+    else:
+        return None
+    sections, cur, depth = [], [], 0
+    for ch in body:
+        if ch == "[":
+            depth += 1; cur.append(ch)
+        elif ch == "]":
+            if depth: depth -= 1
+            cur.append(ch)
+        elif ch == "/" and depth == 0:
+            sections.append("".join(cur)); cur = []
+        else:
+            cur.append(ch)
+    sections.append("".join(cur))
+    if len(sections) > 5:
+        sections = sections[:4] + ["/".join(sections[4:])]
+    return sections
+
+class _TopLevelBracket:
+    @staticmethod
+    def findall(text):
+        out, depth, start = [], 0, -1
+        for i, c in enumerate(text):
+            if c == "[":
+                if depth == 0: start = i + 1
+                depth += 1
+            elif c == "]" and depth:
+                depth -= 1
+                if depth == 0 and start >= 0:
+                    out.append(text[start:i]); start = -1
+        return [] if depth else out
+
+ANOM_RE = re.compile(r"-([0-9]+)([abuxo])(?:_|$)")
+RING_RE = re.compile(r"^(\d+)-(\d+|\?)$")
+
+def parse_record(wurcs):
+    """Return dict with sections, residue defs, per-instance def index, anomeric pos, LIN entries."""
+    s = split_sections(wurcs)
+    if s is None or len(s) < 4:
+        return None
+    defs = _TopLevelBracket.findall(s[2])
+    idx_list = s[3].split("-") if s[3] else []
+    lin = s[4] if len(s) > 4 else ""
+    anom, skel, ring, subs = [], [], [], []
+    for di in idx_list:
+        try:
+            d = defs[int(di) - 1]
+        except (IndexError, ValueError):
+            anom.append(None); skel.append(None); ring.append(None); subs.append(set()); continue
+        m = ANOM_RE.search(d)
+        anom.append(int(m.group(1)) if m else None)
+        parts = d.split("_")
+        skel.append(parts[0].split("-")[0])
+        r = None; sb = set()
+        for p in parts[1:]:
+            mr = RING_RE.match(p)
+            if mr:
+                r = (int(mr.group(1)), mr.group(2)); continue
+            # substituent forms like '2*NCC/3=O', '3|4*OCC/3=O', '6%?%*OC'
+            for mm in re.finditer(r"(\d+)(?:%\?%)?\*", p):
+                sb.add(int(mm.group(1)))
+        ring.append(r); subs.append(sb)
+    return dict(wurcs=wurcs, sections=s, defs=defs, idx_list=idx_list, lin=lin,
+                anom=anom, skel=skel, ring=ring, subs=subs, nres=len(idx_list))
+
+# ---- alternation groups -------------------------------------------------
+ALT_GROUP_RE = re.compile(r"(?:[A-Za-z]+[0-9?]+)(?:\|[A-Za-z]+[0-9?]+)+")
+SIDE_RE = re.compile(r"^([A-Za-z]+)([0-9?]+)$")
+
+def alt_groups(entry):
+    return [(m.group(0), m.start(), m.end()) for m in ALT_GROUP_RE.finditer(entry)]
+
+def classify_group(text):
+    members = text.split("|")
+    parsed = []
+    for m in members:
+        mm = SIDE_RE.match(m)
+        if not mm: return None
+        parsed.append((mm.group(1), mm.group(2)))
+    residues = {p[0] for p in parsed}
+    positions = {p[1] for p in parsed}
+    n = len(parsed)
+    if len(residues) == 1 and len(positions) == n:
+        kind = "POS_ALT"
+    elif len(positions) == 1 and len(residues) == n:
+        kind = "RES_ALT_Q" if "?" in positions else "RES_ALT"
+    elif len(residues) == 1:
+        kind = "POS_ALT_DUP"
+    elif len(positions) == 1:
+        kind = "RES_ALT_DUP"
+    else:
+        kind = "JOINT_ALT"
+    return dict(kind=kind, n=n, residues=sorted(residues), positions=sorted(positions),
+                parsed=parsed, all_q=(positions == {"?"}), any_q=("?" in positions))
+
+# split a LIN entry into left/right around the top-level '-' that separates the two sides
+LINK_SPLIT_RE = re.compile(r"^(?P<L>[A-Za-z0-9?|%]+?)(?P<lb>\}?)-(?P<rb>\{?)(?P<R>[A-Za-z0-9?|%]+)(?P<tail>.*)$")
+
+def split_entry(entry):
+    m = LINK_SPLIT_RE.match(entry)
+    if not m: return None
+    return m.group("L"), m.group("R"), m.group("lb"), m.group("rb"), m.group("tail")

releases/2026-10-02/iar_inference/README.md

@@ -0,0 +1,58 @@
+# Full-checkpoint IAR inference on two recorded cases
+
+This entry point loads the full frozen BERTose WA3 checkpoint and runs the saved 211-class linkage readout on two real, previously executed single-linkage cases. It preserves the original masked side channels, training-frequency-weighted neutral linkage embedding, input-of-`sequence_head` feature, NumPy float32 feature normalization, 0.80 acceptance threshold and maximum of three rounds. No fitting occurs.
+
+The fixture was rebuilt with the frozen tokenizer and official WURCS helper in Slurm job 16662851. That job accepted `g8-h2` for the benchmark case and abstained on the grey-seal case. These two cases are an inference check, not an estimate of completion accuracy. The full portable forward passed in job 16683971; the earlier preparation check recorded here loaded no model.
+
+## Files and dependencies
+
+Keep these three released directories together, or supply the two root arguments below:
+
+```text
+code/
+  iar_inference/       # this runner, configuration and two-case fixtures
+  iar_completion/      # saved readout, metadata, original source and vocabulary
+  bertose_source/      # unchanged model sources and small component authorities
+```
+
+`config.json` pins the 14 required files under `bertose_source`, five files under `iar_completion`, copied helpers and four fixture files. The full checkpoint is supplied separately through `--checkpoint`; it is not copied here. Its required SHA-256 is `8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82`.
+
+Python 3.10 or later is required. `requirements.txt` records the PyTorch and NumPy versions used by the executed CPU reference. Use a CPU-capable PyTorch build. The runner always uses CPU float32, even on a machine with CUDA. Allow several GB of memory for the complete historical checkpoint and model. On Nova, run the full command only in a Slurm compute allocation.
+
+## Run
+
+Check the small files without importing PyTorch or opening the checkpoint:
+
+```bash
+python code/iar_inference/infer.py --preflight-only
+```
+
+Run the full checkpoint and compare both cases with the saved execution:
+
+```bash
+python code/iar_inference/infer.py \
+  --checkpoint /absolute/path/to/review_md20x6_checkpoint_best.pt \
+  --output-dir /absolute/path/to/new_iar_output \
+  --threads 4
+```
+
+The output directory must not exist and its parent must exist. To relocate the companion artifacts, add `--source-root /absolute/path/to/bertose_source` and `--readout-root /absolute/path/to/iar_completion`. Their internal relative layouts and bytes must remain intact. No Nova path, Java installation, training dataset or scheduler is required by this runner.
+
+A successful full run writes `inference_report.json` and two `caseN_pre_sequence_head.npy` arrays. It must report `PASS_PORTABLE_FULL_WA3_TWO_CASE_REFERENCE_CHECK`, 505 strictly loaded state entries, 138,487,995 model parameters, 12 verified component bindings, two finite model forwards, the recorded acceptance/abstention decisions and the same ordered top-10 token IDs. Hidden vectors and probabilities must agree with the CPU reference using `atol=2e-5, rtol=2e-5`; exact equality and maximum hidden differences are reported separately. This tolerance is an explicit smoke-test criterion, not a claim of historical CUDA bitwise replay. A mismatch fails the run.
+
+## What the loader preserves
+
+The loader imports the byte-pinned R5 composite and MD factory from the released source tree. The factory receives the exact original composite class and module through the two attributes it uses from the training executor. It constructs the original `A111`/`A1111`, 2,114-token model with temporal size 128. It retains the unmodified production configuration validation, constructor authority checks, no-follow authority-file reads, tensor-surface validation and live model contract. It also explicitly rechecks the component authorities after strict checkpoint loading. `isolated_test_fixture` remains false.
+
+The original R5 source pin matches the R5 executor's bound source. Its constructor independently validates the frozen R4 lineage, sequence vocabulary and tokenizer bindings, topology source and MS authority/receipt/certificate. The loader neither edits those checks nor changes their archival authorization flags. It does not invoke the training launcher, optimizer/planner authorities or the later static-release launch bootstrap. Those gates authorize a different operation: this entry point has no training path and supplies explicitly absent MS, static and MD carriers, as the executed IAR smoke did. Full checkpoint loading does not establish that active physical-modality inference is portable.
+
+`original_inference_helpers.py` contains only eight verbatim function definitions from the final historical IAR source: the absent-carrier constructor, hook/capture utilities and forward helper, plus its failure function. Preflight compares their ASTs with that pinned source. The historical module itself is not imported because its top level changes `builtins.open` and requires a `WORK` environment variable. The saved `iar_completion/readout.py` is used unchanged. The full historical checkpoint uses `torch.load(..., weights_only=False)` only after its complete bytes match the mandatory SHA-256, through the same open file descriptor; do not replace this with untrusted checkpoint bytes.
+
+## Scope limits
+
+- The runner accepts only the two byte-pinned rebuilt fixture cases. Their WURCS strings and helper records are provenance; raw WURCS is not converted at runtime. Moving the fixture files does not require regenerating them, so no input export helper is needed.
+- General glycan completion, new masking cases, residue or multi-token fallback, corpus reconstruction and full historical metrics are outside this executable interface.
+- The complete checkpoint is loaded, but the two forwards exercise sequence inference with MS, static and MD explicitly absent. Active carrier paths, CUDA and other checkpoints are untested here.
+- A passing small-file preflight does not establish successful checkpoint loading or numerical inference. Only a completed full-run report does so for these two cases.
+
+The public runner passed a fresh-extraction CPU execution in Nova job 16683971: full strict loading, both hidden vectors bitwise equal to the prior reference, and unchanged ordered predictions and abstention. The receipt is in `../provenance/portable_execution_20260930/iar_portable_report.json`.

releases/2026-10-02/iar_inference/SHA256SUMS

@@ -0,0 +1,10 @@
+8fc1d034d7b8a3d7c12cdfa958f1b5825be73cedabce8e96a83441e883bea0e7  README.md
+043a38744f9fd832181d822ae8481488d954604bf615b2eb05c4c8ad29794325  config.json
+a212cfbd49ec2f951e942c92caaac63260687a626eca588cb692d86bb1e52198  fixtures/case0_pre_sequence_head.npy
+6ffca438526432a33168a85a0fee1158fd2a9c9f23ecb97f587235f204ae50b3  fixtures/case1_pre_sequence_head.npy
+60ac0c0fd1b6e0ada2d847d1fccff4f6fe7c085aab3146247dc5d7bfebbabc27  fixtures/rebuilt_two_case_inputs.json
+60dcdb6262457962da84c7b239c194fac343bd8d27db0e05f15906acb9bf5f4b  fixtures/reference_smoke_report.json
+9237b349668ea3fb5266f4696169fd958e9f997e5064ede0ab06e41859b17361  infer.py
+87fa484e1f6105fa476dff4cf8c7e6aea71a2aac537796131a4858632f54b906  original_inference_helpers.py
+4e36f9237dc494eb47898ff3ab9a5b1a483f5004aa933a5294af794edd0757ce  preparation_validation.json
+16e89b25a13eabc8586ba2a8ec32890ecf321f652b03f7548c63112d13cb2e62  requirements.txt

releases/2026-10-02/iar_inference/config.json

@@ -0,0 +1,178 @@
+{
+  "schema": "bertose_portable_two_case_iar_v1",
+  "source_root": "../bertose_source",
+  "readout_root": "../iar_completion",
+  "model_sources": {
+    "r5": "writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r5/review_a5_native_eight_composite_r5.py",
+    "md_core": "writing/review/multimodal/runtime/md_temporal_20x6_end_to_end_20260802_r3_native_intersection/review_md_temporal_20x6_core_r3.py"
+  },
+  "source_files": [
+    {
+      "path": "writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r4/review_a5_native_eight_composite_r4.py",
+      "bytes": 70358,
+      "sha256": "52a311636e7631b97711aab63aec28e2ada47a446d1aecc1a47921d584f69f9d"
+    },
+    {
+      "path": "writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r5/review_a5_native_eight_composite_r5.py",
+      "bytes": 58459,
+      "sha256": "24c35257fc61e1c9c77630d2b0075775a7f46b6500ecb5f175ef8f42bd214e0e"
+    },
+    {
+      "path": "writing/review/multimodal/runtime/md_temporal_20x6_end_to_end_20260802_r3_native_intersection/review_md_temporal_20x6_core_r3.py",
+      "bytes": 48643,
+      "sha256": "3e96d8092239c2c21f217ad5bae4ee7e07dbe0f7630b213bad468d6b08d3b1c1"
+    },
+    {
+      "path": "writing/review/multimodal/runtime/a5_pretraining_failclosed_integration_20260721_r5/review_a5_native_eight_r4_lineage_receipt_r1.json",
+      "bytes": 1716,
+      "sha256": "b5fbdff168de23676208484ccccc3cc32f613ea411d193e6d8930456e8edeeef"
+    },
+    {
+      "path": "writing/review/multimodal/outputs/review_a5_official_ragged_sequence_topology_runtime_20260721_r3/review_a5_topology_loss_v2.py",
+      "bytes": 8067,
+      "sha256": "64eaf9174f523ae909c84987049d071bf3869ca8e83919f14f0572ef77b0530e"
+    },
+    {
+      "path": "writing/review/multimodal/runtime/a5_ms_acquisition_top30_v3_20260721_r3/review_a5_ms_acquisition_top30_runtime_v3.py",
+      "bytes": 43711,
+      "sha256": "68c0d543c5411276ef56c7072bded4ebda886f46b9fa4ebf3c95c1e54c1a08c6"
+    },
+    {
+      "path": "data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_sequence_package_receipt.json",
+      "bytes": 5797,
+      "sha256": "399df3de2b6c4d5e88aa442c8326214ab9cff2e8f0411e6921762bbade1475ba"
+    },
+    {
+      "path": "data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_sequence_package_summary.json",
+      "bytes": 7777,
+      "sha256": "93ed219d807d4a7735be96bf7cf6a59a0bd407619925ee194aed6d473048cdf0"
+    },
+    {
+      "path": "data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json",
+      "bytes": 138150,
+      "sha256": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b"
+    },
+    {
+      "path": "data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_training_a5_wurcs_bpe.py",
+      "bytes": 14161,
+      "sha256": "6591b854962c278dc797981c942e114c18a26e97af43029c1d539bae3badb2f4"
+    },
+    {
+      "path": "data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_frozen_sequence_tree_runtime.py",
+      "bytes": 11405,
+      "sha256": "10ca4b121d2f22d7a64208e4f05172e7a756b653d0828c9dcc49dd8ea1a5ad04"
+    },
+    {
+      "path": "data/review_ms_acquisition_top30_runtime_20260721_r3/review_a5_ms_acquisition_top30_runtime_authority.json",
+      "bytes": 20541,
+      "sha256": "48914855c4e458ff02452ad4db3743a4fbef12221e0313584db4c2b1bd684cd4"
+    },
+    {
+      "path": "data/review_ms_acquisition_top30_runtime_20260721_r3/review_a5_ms_acquisition_top30_runtime_receipt.json",
+      "bytes": 6260,
+      "sha256": "f654177eb6fde7289b6755812c2be298084697cf0d85159b3ec9da310fe3d4b4"
+    },
+    {
+      "path": "data/review_ms_acquisition_top30_runtime_20260721_r3/review_a5_ms_acquisition_top30_runtime_independent_certificate.json",
+      "bytes": 19121,
+      "sha256": "53098620a5c22dafdc951ba743515b4b10b1673c02f0aa4d881db669584902fa"
+    }
+  ],
+  "readout_files": [
+    {
+      "path": "readout.py",
+      "bytes": 5515,
+      "sha256": "42464d76c743a302bae79ced6b09af9657444c6f977535b5de49dcf59a5a8a90"
+    },
+    {
+      "path": "model_metadata.json",
+      "bytes": 3132,
+      "sha256": "bbf016ce2f1a7dc82940be28397cbe8083da7ad0f5f525b1cf7345fd42a5758d"
+    },
+    {
+      "path": "assets/linkage_readout.pt",
+      "bytes": 663845,
+      "sha256": "a03990a02a1737de05a7fa1739164e84fa6a0a4170ebaa65317a9f3c2f16c0b0"
+    },
+    {
+      "path": "originals/wa3_final_iar_readout_all.py",
+      "bytes": 82622,
+      "sha256": "72f8583bf32799ba29c09829d138900c0cbb589f73bd278f389da6fa8a786730"
+    },
+    {
+      "path": "runtime_snapshot/project/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json",
+      "bytes": 138150,
+      "sha256": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b"
+    }
+  ],
+  "local_files": [
+    {
+      "path": "original_inference_helpers.py",
+      "bytes": 4608,
+      "sha256": "87fa484e1f6105fa476dff4cf8c7e6aea71a2aac537796131a4858632f54b906"
+    },
+    {
+      "path": "fixtures/case0_pre_sequence_head.npy",
+      "bytes": 3200,
+      "sha256": "a212cfbd49ec2f951e942c92caaac63260687a626eca588cb692d86bb1e52198"
+    },
+    {
+      "path": "fixtures/case1_pre_sequence_head.npy",
+      "bytes": 3200,
+      "sha256": "6ffca438526432a33168a85a0fee1158fd2a9c9f23ecb97f587235f204ae50b3"
+    },
+    {
+      "path": "fixtures/rebuilt_two_case_inputs.json",
+      "bytes": 42915,
+      "sha256": "60ac0c0fd1b6e0ada2d847d1fccff4f6fe7c085aab3146247dc5d7bfebbabc27"
+    },
+    {
+      "path": "fixtures/reference_smoke_report.json",
+      "bytes": 7532,
+      "sha256": "60dcdb6262457962da84c7b239c194fac343bd8d27db0e05f15906acb9bf5f4b"
+    }
+  ],
+  "original_helper_functions": [
+    "fail",
+    "all_absent",
+    "_linkage_hook",
+    "find_linkage_embedding",
+    "_cap_hook",
+    "find_lm_projection",
+    "_gather_h",
+    "_forward"
+  ],
+  "checkpoint": {
+    "sha256": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "md_cell_id": "A1111",
+    "base_cell_id": "A111",
+    "best_epoch": 58,
+    "state_entries": 505,
+    "parameter_count": 138487995,
+    "vocabulary_size": 2114,
+    "md_temporal_size": 128
+  },
+  "inference": {
+    "device": "cpu",
+    "dtype": "float32",
+    "threshold": 0.8,
+    "maximum_rounds": 3,
+    "neutral_module": "sequence_embeddings.linkage_embeddings",
+    "hidden_module": "sequence_head",
+    "neutral_training_counts": [
+      97966,
+      150442,
+      219104,
+      95827,
+      13486,
+      11976,
+      23,
+      36422
+    ],
+    "hidden_allclose_atol": 2e-05,
+    "hidden_allclose_rtol": 2e-05,
+    "probability_allclose_atol": 2e-05,
+    "probability_allclose_rtol": 2e-05
+  },
+  "scope": "The two byte-pinned, official-helper-rebuilt single-linkage cases only; physical modalities explicitly absent. No refit, raw-WURCS conversion, fallback, corpus metrics or training authorization."
+}

releases/2026-10-02/iar_inference/fixtures/case0_pre_sequence_head.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a212cfbd49ec2f951e942c92caaac63260687a626eca588cb692d86bb1e52198
+size 3200

releases/2026-10-02/iar_inference/fixtures/case1_pre_sequence_head.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ffca438526432a33168a85a0fee1158fd2a9c9f23ecb97f587235f204ae50b3
+size 3200

releases/2026-10-02/iar_inference/fixtures/rebuilt_two_case_inputs.json

@@ -0,0 +1,3718 @@
+[
+  {
+    "dataset": "bench1392",
+    "source_case_id": "g0000_s00_linkage_38_38",
+    "recorded_source_sha256": "124effa978c07bab00e7056c41d4c727a2a4c7d766d8d2a510c11a0fc52d3721",
+    "official_helper": {
+      "rooted": true,
+      "depths": [
+        0,
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9
+      ],
+      "parents": [
+        -1,
+        0,
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8
+      ],
+      "helper_error": false
+    },
+    "rebuilt_case": {
+      "case_id": "g0000_s00_linkage_38_38",
+      "glycan_index": 0,
+      "wurcs": "WURCS=2.0/2,10,9/[AUd21122h_5*NCC/3=O][Aad21122h-2a_2-6_5*NCC/3=O]/1-2-2-2-2-2-2-2-2-2/a8-b2_b8-c2_c8-d2_d8-e2_e8-f2_f8-g2_g8-h2_h8-i2_i8-j2",
+      "mask_plan": "linkage:1",
+      "units": [
+        {
+          "g": 35,
+          "unit_type": "linkage",
+          "unit_text": "g8-h2"
+        }
+      ],
+      "wa0_iterative_span_exact": true,
+      "wa0_initial_span_exact_top1": true,
+      "unit_text": "linkage:g8-h2",
+      "positions": [
+        43
+      ],
+      "truth_ids": [
+        1720
+      ],
+      "masked_ids": [
+        2,
+        316,
+        225,
+        254,
+        208,
+        225,
+        254,
+        208,
+        225,
+        254,
+        208,
+        225,
+        254,
+        208,
+        225,
+        254,
+        208,
+        225,
+        254,
+        208,
+        225,
+        254,
+        208,
+        225,
+        254,
+        208,
+        225,
+        254,
+        208,
+        225,
+        1283,
+        568,
+        72,
+        557,
+        436,
+        1484,
+        2015,
+        75,
+        557,
+        619,
+        76,
+        557,
+        348,
+        4,
+        1380,
+        79,
+        557,
+        585,
+        3,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "attention_mask": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "residue_ids": [
+        -1,
+        0,
+        0,
+        1,
+        1,
+        1,
+        2,
+        2,
+        2,
+        3,
+        3,
+        3,
+        4,
+        4,
+        4,
+        5,
+        5,
+        5,
+        6,
+        6,
+        6,
+        7,
+        7,
+        7,
+        8,
+        8,
+        8,
+        9,
+        9,
+        9,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -2,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1
+      ],
+      "branch_depths": [
+        0,
+        0,
+        0,
+        1,
+        1,
+        1,
+        2,
+        2,
+        2,
+        3,
+        3,
+        3,
+        4,
+        4,
+        4,
+        5,
+        5,
+        5,
+        6,
+        6,
+        6,
+        7,
+        7,
+        7,
+        8,
+        8,
+        8,
+        9,
+        9,
+        9,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "linkage_types": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "branch_depths_blank": [
+        0,
+        0,
+        0,
+        1,
+        1,
+        1,
+        2,
+        2,
+        2,
+        3,
+        3,
+        3,
+        4,
+        4,
+        4,
+        5,
+        5,
+        5,
+        6,
+        6,
+        6,
+        7,
+        7,
+        7,
+        8,
+        8,
+        8,
+        9,
+        9,
+        9,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "linkage_types_blank": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        8,
+        9,
+        8,
+        8,
+        8,
+        8,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "enumerated_alternative": false,
+      "unknown_question_mark": false,
+      "wa3_truth_uses_invalid_token": false,
+      "single_answer": true
+    }
+  },
+  {
+    "dataset": "seal162",
+    "source_case_id": "g0000_s00_linkage_9_9",
+    "recorded_source_sha256": "86b08c4b8c5081ee90eef3401ae5b0a09595c301f6c79f3d892521b3ea3e33d1",
+    "official_helper": {
+      "rooted": true,
+      "depths": [
+        0,
+        1,
+        2
+      ],
+      "parents": [
+        -1,
+        0,
+        1
+      ],
+      "helper_error": false
+    },
+    "rebuilt_case": {
+      "case_id": "g0000_s00_linkage_9_9",
+      "glycan_index": 0,
+      "wurcs": "WURCS=2.0/3,3,2/[h2122h_2*NCC/3=O][a2112h-1b_1-5][a2122h-1b_1-5_2*NCC/3=O_6*OSO/3=O/3=O]/1-2-3/a4-b1_b3-c1",
+      "mask_plan": "linkage:1",
+      "units": [
+        {
+          "g": 8,
+          "unit_type": "linkage",
+          "unit_text": "a4-b1"
+        }
+      ],
+      "wa0_iterative_span_exact": true,
+      "wa0_initial_span_exact_top1": true,
+      "unit_text": "linkage:a4-b1",
+      "positions": [
+        9
+      ],
+      "truth_ids": [
+        228
+      ],
+      "masked_ids": [
+        2,
+        525,
+        139,
+        190,
+        119,
+        177,
+        119,
+        139,
+        333,
+        4,
+        291,
+        3,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "attention_mask": [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "residue_ids": [
+        -1,
+        0,
+        0,
+        1,
+        1,
+        2,
+        2,
+        2,
+        2,
+        -2,
+        -2,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1
+      ],
+      "branch_depths": [
+        0,
+        0,
+        0,
+        1,
+        1,
+        2,
+        2,
+        2,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "linkage_types": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        3,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "branch_depths_blank": [
+        0,
+        0,
+        0,
+        1,
+        1,
+        2,
+        2,
+        2,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "linkage_types_blank": [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        9,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "enumerated_alternative": false,
+      "unknown_question_mark": false,
+      "wa3_truth_uses_invalid_token": false,
+      "single_answer": true
+    }
+  }
+]

releases/2026-10-02/iar_inference/fixtures/reference_smoke_report.json

@@ -0,0 +1,253 @@
+{
+  "schema": "iar_two_real_saved_readout_full_model_smoke_v1",
+  "status": "PASS_FULL_WA3_STRICT_LOAD_AND_TWO_REAL_SAVED_READOUT_FORWARDS",
+  "started_unix": 1790740892.3816009,
+  "script_sha256": "d757fda5194ba6a6ce9fc03096b5596e47f7889844034aa70efbac33fb8235cb",
+  "scope": "Strict full WA3 plus two recorded single-linkage cases and fixed saved readout; no refit or metrics.",
+  "limits": [
+    "CPU smoke, not historical CUDA numerical replay or model-quality evidence.",
+    "No residue or multi-token fallback; no full corpus parity or seeded case reconstruction.",
+    "Original Nova native authority bootstrap can read complete sequence/topology packages."
+  ],
+  "manifest_sha256": "440a748a14e9c09d017677ef3477d19ed02169a8e5ee048ff8b3f05bdaa1a12d",
+  "runtime": {
+    "python": "3.10.16",
+    "torch": "2.9.1+cu128",
+    "numpy": "2.2.6",
+    "device": "cpu",
+    "precision": "float32",
+    "threads": 4,
+    "host": "nova18-wide-4",
+    "slurm_job_id": "16662851"
+  },
+  "phase": "two_case_saved_readout_forward",
+  "inputs_sha256": "60ac0c0fd1b6e0ada2d847d1fccff4f6fe7c085aab3146247dc5d7bfebbabc27",
+  "full_model": {
+    "state_entries": 505,
+    "parameters": 138487995,
+    "strict_load": true,
+    "checkpoint_sha256": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "neutral_vector": {
+      "shape": [
+        768
+      ],
+      "dtype": "float32",
+      "sha256_c_order_bytes": "297bc451bcb34097045af18278e9cbeabbf38fdb22777d77aee87001784d4b29"
+    },
+    "hidden_capture_input_of": "sequence_head"
+  },
+  "readout": {
+    "sha256": "a03990a02a1737de05a7fa1739164e84fa6a0a4170ebaa65317a9f3c2f16c0b0",
+    "classes": 211,
+    "fit": {
+      "dev_accuracy_for_selection": 0.7359,
+      "best_epoch": 46,
+      "tokens": 211,
+      "train_samples": 111989,
+      "development_samples": 27690,
+      "feature_dim": 768
+    },
+    "refit": false
+  },
+  "forward_calls": 2,
+  "cases": [
+    {
+      "dataset": "bench1392",
+      "case_id": "g0000_s00_linkage_38_38",
+      "used_saved_readout": true,
+      "wa3_position": 43,
+      "truth_token_id": 1720,
+      "truth_token": "g8-h2",
+      "final_token_id": 1720,
+      "final_token": "g8-h2",
+      "abstained": false,
+      "rounds": [
+        {
+          "iteration": 1,
+          "hidden_sha256_c_order_bytes": "ff29f35c4eb22549a5185b89c2bf9dabe5ff7f4a3fdc44291cbfa724eb5349ee",
+          "top10": [
+            {
+              "token_id": 1720,
+              "token": "g8-h2",
+              "probability": 0.9999593496322632
+            },
+            {
+              "token_id": 1261,
+              "token": "g3-h2",
+              "probability": 4.006435483461246e-05
+            },
+            {
+              "token_id": 1380,
+              "token": "h8-i2",
+              "probability": 2.607788189834537e-07
+            },
+            {
+              "token_id": 1122,
+              "token": "d3-e2",
+              "probability": 1.445049662152087e-07
+            },
+            {
+              "token_id": 531,
+              "token": "g2-h1",
+              "probability": 1.0591251964342518e-07
+            },
+            {
+              "token_id": 544,
+              "token": "g3-h1",
+              "probability": 6.952672038096352e-08
+            },
+            {
+              "token_id": 1548,
+              "token": "m6-n2",
+              "probability": 1.4976388129639417e-08
+            },
+            {
+              "token_id": 1572,
+              "token": "h3-i2",
+              "probability": 8.80937189862152e-09
+            },
+            {
+              "token_id": 710,
+              "token": "f3-g2",
+              "probability": 6.006392716528808e-09
+            },
+            {
+              "token_id": 486,
+              "token": "g4-h1",
+              "probability": 4.912561468728427e-09
+            }
+          ],
+          "accepted": true
+        }
+      ]
+    },
+    {
+      "dataset": "seal162",
+      "case_id": "g0000_s00_linkage_9_9",
+      "used_saved_readout": true,
+      "wa3_position": 9,
+      "truth_token_id": 228,
+      "truth_token": "a4-b1",
+      "final_token_id": 4,
+      "final_token": "[MASK]",
+      "abstained": true,
+      "rounds": [
+        {
+          "iteration": 1,
+          "hidden_sha256_c_order_bytes": "1cd693d3ea8df175d65f0eca3673ce2a73dff666d1cf06aa84bf4943127c3be8",
+          "top10": [
+            {
+              "token_id": 228,
+              "token": "a4-b1",
+              "probability": 0.7713369131088257
+            },
+            {
+              "token_id": 262,
+              "token": "a3-b1",
+              "probability": 0.2158111184835434
+            },
+            {
+              "token_id": 404,
+              "token": "a6-b1",
+              "probability": 0.01060701534152031
+            },
+            {
+              "token_id": 399,
+              "token": "a2-b1",
+              "probability": 0.002030769130215049
+            },
+            {
+              "token_id": 518,
+              "token": "a5-b1",
+              "probability": 9.787840826902539e-05
+            },
+            {
+              "token_id": 1282,
+              "token": "a7-b1",
+              "probability": 7.618743984494358e-05
+            },
+            {
+              "token_id": 710,
+              "token": "f3-g2",
+              "probability": 1.4471691429207567e-05
+            },
+            {
+              "token_id": 1252,
+              "token": "d6-g1",
+              "probability": 8.236345820478164e-06
+            },
+            {
+              "token_id": 1331,
+              "token": "c3-d2",
+              "probability": 2.9395614546956494e-06
+            },
+            {
+              "token_id": 466,
+              "token": "h4-i1",
+              "probability": 1.904394366647466e-06
+            }
+          ],
+          "accepted": false
+        },
+        {
+          "iteration": 2,
+          "hidden_sha256_c_order_bytes": "1cd693d3ea8df175d65f0eca3673ce2a73dff666d1cf06aa84bf4943127c3be8",
+          "top10": [
+            {
+              "token_id": 228,
+              "token": "a4-b1",
+              "probability": 0.7713369131088257
+            },
+            {
+              "token_id": 262,
+              "token": "a3-b1",
+              "probability": 0.2158111184835434
+            },
+            {
+              "token_id": 404,
+              "token": "a6-b1",
+              "probability": 0.01060701534152031
+            },
+            {
+              "token_id": 399,
+              "token": "a2-b1",
+              "probability": 0.002030769130215049
+            },
+            {
+              "token_id": 518,
+              "token": "a5-b1",
+              "probability": 9.787840826902539e-05
+            },
+            {
+              "token_id": 1282,
+              "token": "a7-b1",
+              "probability": 7.618743984494358e-05
+            },
+            {
+              "token_id": 710,
+              "token": "f3-g2",
+              "probability": 1.4471691429207567e-05
+            },
+            {
+              "token_id": 1252,
+              "token": "d6-g1",
+              "probability": 8.236345820478164e-06
+            },
+            {
+              "token_id": 1331,
+              "token": "c3-d2",
+              "probability": 2.9395614546956494e-06
+            },
+            {
+              "token_id": 466,
+              "token": "h4-i1",
+              "probability": 1.904394366647466e-06
+            }
+          ],
+          "accepted": false
+        }
+      ]
+    }
+  ],
+  "finished_unix": 1790740986.703624
+}

releases/2026-10-02/iar_inference/infer.py

@@ -0,0 +1,290 @@
+#!/usr/bin/env python3
+"""Strict full-WA3 CPU inference on two recorded single-linkage IAR cases.
+
+The full model uses unchanged, pinned released classes and authority checks.
+This entry point neither fits a readout nor imports the historical main script.
+"""
+from pathlib import Path
+import argparse
+import ast
+import hashlib
+import importlib.util
+import json
+import os
+import platform
+import sys
+import time
+from types import SimpleNamespace
+
+
+ROOT = Path(__file__).resolve().parent
+sys.dont_write_bytecode = True
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def sha256(path):
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as handle:
+        for block in iter(lambda: handle.read(4 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def load_module(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    require(spec is not None and spec.loader is not None, "Cannot import " + str(path))
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def read_config(path=ROOT / "config.json", source_root=None, readout_root=None):
+    path = Path(path).resolve()
+    config = json.loads(path.read_text())
+    require(config["schema"] == "bertose_portable_two_case_iar_v1", "Unknown config schema")
+    source = Path(source_root).resolve() if source_root else (path.parent / config["source_root"]).resolve()
+    readout = Path(readout_root).resolve() if readout_root else (path.parent / config["readout_root"]).resolve()
+    return config, source, readout
+
+
+def preflight(config, source_root, readout_root):
+    """Check small source/authority/fixture bytes without torch or a checkpoint."""
+    verified = []
+    for root, key in ((source_root, "source_files"), (readout_root, "readout_files"), (ROOT, "local_files")):
+        for item in config[key]:
+            path = root / item["path"]
+            require(path.is_file() and path.stat().st_size == item["bytes"], "Missing/changed file: " + str(path))
+            require(sha256(path) == item["sha256"], "SHA-256 differs: " + str(path))
+            verified.append({"path": str(path), "sha256": item["sha256"]})
+    # Verify that the copied helpers retain the original function ASTs. Do not
+    # import the monolithic historical source (it changes builtins.open).
+    def functions(path):
+        return {n.name: ast.dump(n, include_attributes=False) for n in ast.parse(path.read_text()).body
+                if isinstance(n, ast.FunctionDef)}
+    original = functions(readout_root / "originals/wa3_final_iar_readout_all.py")
+    portable = functions(ROOT / "original_inference_helpers.py")
+    names = config["original_helper_functions"]
+    require(set(portable) == set(names), "Unexpected portable inference helper")
+    require(all(portable[n] == original[n] for n in names), "Original helper semantics changed")
+    records = json.loads((ROOT / "fixtures/rebuilt_two_case_inputs.json").read_text())
+    require(len(records) == 2, "Expected exactly two recorded cases")
+    for record in records:
+        case = record["rebuilt_case"]
+        require(len(case["positions"]) == len(case["units"]) == len(case["truth_ids"]) == 1,
+                "Only one masked token and one semantic unit are supported")
+        require(case["single_answer"] and case["units"][0]["unit_type"] == "linkage", "Not an ordinary single linkage")
+        for key in ("masked_ids", "attention_mask", "residue_ids", "branch_depths_blank", "linkage_types_blank"):
+            require(len(case[key]) == 256 and all(type(v) is int for v in case[key]), "Invalid input channel: " + key)
+        position = case["positions"][0]
+        require(0 <= position < 256 and case["attention_mask"][position] == 1
+                and case["masked_ids"][position] == 4 and case["residue_ids"][position] == -2
+                and case["branch_depths_blank"][position] == 0 and case["linkage_types_blank"][position] == 9,
+                "Masked linkage channel contract changed")
+    return records, verified
+
+
+def load_model(checkpoint, config, source_root):
+    """Load the pinned full checkpoint through the original production classes.
+
+    Caller must run preflight first. The R5 constructor independently reopens
+    all twelve component authorities with its original no-follow traversal.
+    """
+    import torch
+    checkpoint = Path(checkpoint).resolve()
+    expected = config["checkpoint"]
+    # Keep the same descriptor for hashing and deserialization. weights_only=False
+    # is permitted only for these exact, predeclared historical checkpoint bytes.
+    with checkpoint.open("rb") as handle:
+        before = os.fstat(handle.fileno())
+        digest = hashlib.sha256()
+        for block in iter(lambda: handle.read(4 << 20), b""):
+            digest.update(block)
+        require(digest.hexdigest() == expected["sha256"], "Full checkpoint SHA-256 differs; refusing deserialization")
+        handle.seek(0)
+        saved = torch.load(handle, map_location="cpu", weights_only=False)
+        after = os.fstat(handle.fileno())
+        require((before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns)
+                == (after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns), "Checkpoint changed during load")
+    require(saved.get("md_cell_id") == expected["md_cell_id"]
+            and int(saved["selection"]["best_epoch"]) == expected["best_epoch"], "Checkpoint cell/epoch identity differs")
+    r5 = load_module("_portable_iar_r5", source_root / config["model_sources"]["r5"])
+    md = load_module("_portable_iar_md", source_root / config["model_sources"]["md_core"])
+    # The original factory accesses exactly these two attributes of the executor.
+    # No training planner, scheduler or static-release launcher is needed here.
+    executor_binding = SimpleNamespace(_composite=r5, NativeEightCompositeR5=r5.NativeEightCompositeR5)
+    model_type = md.make_md_enabled_composite_class(executor_binding)
+    model = model_type(r5.NativeEightConfig(cell_id=expected["base_cell_id"], seq_vocab_size=expected["vocabulary_size"]),
+                       md_cell_id=expected["md_cell_id"], md_temporal_size=expected["md_temporal_size"])
+    require(len(saved["model_state"]) == expected["state_entries"], "Checkpoint state count differs")
+    model.load_state_dict(saved["model_state"], strict=True)
+    del saved
+    require(len(model.state_dict()) == expected["state_entries"]
+            and sum(p.numel() for p in model.parameters()) == expected["parameter_count"], "Full model inventory differs")
+    require(all(p.dtype == torch.float32 for p in model.parameters()), "Expected float32 model parameters")
+    model.eval().requires_grad_(False)
+    model.verify_live_contract()
+    bindings = dict(model.reverify_component_authorities())
+    require(bindings == dict(r5.EXPECTED_COMPONENT_BINDINGS), "Component authority bindings differ")
+    return model, bindings
+
+
+def run_cases(model, records, config, readout_root, output_dir):
+    import numpy as np
+    import torch
+    helper = load_module("_portable_iar_helpers", ROOT / "original_inference_helpers.py")
+    readout = load_module("_portable_iar_readout", readout_root / "readout.py")
+    payload, linear, metadata = readout.load_readout(readout_root)
+    contract = config["inference"]
+    require(metadata["linkage_input"]["training_counts"] == contract["neutral_training_counts"]
+            and metadata["evaluation"]["threshold"] == contract["threshold"]
+            and metadata["evaluation"]["rounds"] == contract["maximum_rounds"], "Readout inference contract differs")
+    require(metadata["encoder"]["checkpoint_sha256"] == config["checkpoint"]["sha256"], "Readout encoder binding differs")
+    vocab = json.loads((readout_root / metadata["vocabulary"]["path"]).read_text())["token_to_id"]
+    id_to_token = {v: k for k, v in vocab.items()}
+    cases = [r["rebuilt_case"] for r in records]
+    require(all(c["truth_ids"][0] in payload["token_ids"] for c in cases), "Fixture truth is outside saved readout")
+    lk_name, linkage = helper.find_linkage_embedding(model)
+    head_name, head = helper.find_lm_projection(model)
+    require(lk_name == contract["neutral_module"] and head_name == contract["hidden_module"], "Hook module differs")
+    counts = np.asarray(contract["neutral_training_counts"], dtype=np.float64)
+    weights = torch.as_tensor(counts / counts.sum(), dtype=torch.float32)
+    helper.HOOK["vec"] = (linkage.weight[1:9].detach().float() * weights[:, None]).sum(0)
+    neutral_sha = hashlib.sha256(helper.HOOK["vec"].numpy().tobytes()).hexdigest()
+    hooks = [linkage.register_forward_hook(helper._linkage_hook), head.register_forward_hook(helper._cap_hook)]
+    current = [list(c["masked_ids"]) for c in cases]
+    unresolved = [True] * len(cases)
+    histories = [[] for _ in cases]
+    comparisons = []
+    positions = [(i, c["positions"][0]) for i, c in enumerate(cases)]
+    tensor = lambda key: torch.tensor([c[key] for c in cases], dtype=torch.long)
+    reference = json.loads((ROOT / "fixtures/reference_smoke_report.json").read_text())
+    try:
+        for iteration in range(contract["maximum_rounds"]):
+            helper.CAP["h"] = None
+            logits = helper._forward(model, "cpu", torch.tensor(current, dtype=torch.long),
+                                     tensor("attention_mask"), tensor("residue_ids"), tensor("branch_depths_blank"),
+                                     tensor("linkage_types_blank"), positions)
+            require(tuple(logits.shape) == (2, 256, 2114) and torch.isfinite(logits).all().item(), "Invalid full MLM output")
+            progress = 0
+            for i, case in enumerate(cases):
+                if not unresolved[i]:
+                    continue
+                position = case["positions"][0]
+                hidden = helper._gather_h(2, 256, i, position).float().cpu().numpy()[None, :]
+                require(hidden.shape == (1, 768) and np.isfinite(hidden).all(), "Invalid hidden feature")
+                if iteration == 0:
+                    expected_hidden = np.load(ROOT / ("fixtures/case%d_pre_sequence_head.npy" % i), allow_pickle=False)
+                    matches = bool(np.allclose(hidden, expected_hidden, atol=contract["hidden_allclose_atol"],
+                                               rtol=contract["hidden_allclose_rtol"]))
+                    comparisons.append({"case_id": case["case_id"], "hidden_allclose": matches,
+                                        "hidden_max_abs_difference": float(np.max(np.abs(hidden - expected_hidden))),
+                                        "hidden_bitwise_equal": bool(np.array_equal(hidden, expected_hidden))})
+                    require(matches, "Hidden feature differs from executed reference for " + case["case_id"])
+                    with (output_dir / ("case%d_pre_sequence_head.npy" % i)).open("xb") as handle:
+                        np.save(handle, hidden, allow_pickle=False)
+                probabilities = readout.probabilities(hidden, payload, linear)[0]
+                pp, indices = torch.topk(torch.from_numpy(probabilities), k=10)
+                ids = [int(payload["token_ids"][int(j)]) for j in indices]
+                # Every saved class is verified by load_readout as an ordinary
+                # linkage token; it therefore cannot be a special/ambiguous ID.
+                accepted = float(pp[0]) >= contract["threshold"]
+                histories[i].append({"iteration": iteration + 1,
+                                     "hidden_sha256_c_order_bytes": hashlib.sha256(hidden.tobytes()).hexdigest(),
+                                     "top10": [{"token_id": token, "token": id_to_token[token], "probability": float(p)}
+                                               for token, p in zip(ids, pp)], "accepted": accepted})
+                if accepted:
+                    current[i][position] = ids[0]
+                    unresolved[i] = False
+                    progress += 1
+            if progress == 0:
+                break
+    finally:
+        for hook in hooks:
+            hook.remove()
+        helper.HOOK["mask"] = None
+        helper.CAP["h"] = None
+    results = [{"dataset": record["dataset"], "case_id": case["case_id"], "used_saved_readout": True,
+                "wa3_position": case["positions"][0], "truth_token_id": case["truth_ids"][0],
+                "truth_token": id_to_token[case["truth_ids"][0]], "final_token_id": current[i][case["positions"][0]],
+                "final_token": id_to_token[current[i][case["positions"][0]]], "abstained": unresolved[i], "rounds": histories[i]}
+               for i, (record, case) in enumerate(zip(records, cases))]
+    for result, expected in zip(results, reference["cases"]):
+        for key in ("dataset", "case_id", "wa3_position", "truth_token_id", "final_token_id", "abstained"):
+            require(result[key] == expected[key], "Reference result differs: " + key)
+        require(len(result["rounds"]) == len(expected["rounds"]), "Reference round count differs")
+        for actual_round, expected_round in zip(result["rounds"], expected["rounds"]):
+            require(actual_round["accepted"] == expected_round["accepted"], "Reference acceptance differs")
+            require([x["token_id"] for x in actual_round["top10"]] == [x["token_id"] for x in expected_round["top10"]],
+                    "Reference top-10 token order differs")
+            require(np.allclose([x["probability"] for x in actual_round["top10"]],
+                                [x["probability"] for x in expected_round["top10"]],
+                                atol=contract["probability_allclose_atol"], rtol=contract["probability_allclose_rtol"]),
+                    "Reference probabilities differ")
+    return {"cases": results, "forward_calls": iteration + 1, "reference_comparisons": comparisons,
+            "neutral_vector_sha256_c_order_bytes": neutral_sha,
+            "neutral_vector_bitwise_reference_match": neutral_sha == reference["full_model"]["neutral_vector"]["sha256_c_order_bytes"],
+            "readout": {"sha256": metadata["readout"]["sha256"], "classes": len(payload["token_ids"]), "fit": metadata["fit"], "refit": False}}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--config", type=Path, default=ROOT / "config.json")
+    parser.add_argument("--source-root", type=Path, help="Released bertose_source root; preserves its relative layout")
+    parser.add_argument("--readout-root", type=Path, help="Released iar_completion root")
+    parser.add_argument("--checkpoint", type=Path, help="Full pinned WA3 review_md20x6_checkpoint_best.pt")
+    parser.add_argument("--output-dir", type=Path, help="New directory for report and two hidden feature arrays")
+    parser.add_argument("--threads", type=int, default=4, choices=range(1, 9))
+    parser.add_argument("--preflight-only", action="store_true", help="Small-file integrity and input checks only; no torch/checkpoint load")
+    args = parser.parse_args()
+    config, source, readout = read_config(args.config, args.source_root, args.readout_root)
+    records, verified = preflight(config, source, readout)
+    if args.preflight_only:
+        print(json.dumps({"status": "PASS_PREFLIGHT_ONLY", "verified_files": len(verified), "cases": len(records),
+                          "checkpoint_loaded": False, "model_forward_executed": False}, indent=2))
+        return
+    if args.checkpoint is None or args.output_dir is None:
+        parser.error("--checkpoint and --output-dir are required for inference")
+    output = args.output_dir.absolute()
+    require(output.parent.is_dir() and not output.exists(), "Output directory must be new with an existing parent")
+    output.mkdir()
+    report = {"schema": "bertose_portable_two_case_iar_result_v1", "status": "RUNNING", "started_unix": time.time(),
+              "scope": config["scope"], "config_sha256": sha256(args.config), "inference_script_sha256": sha256(Path(__file__)),
+              "checkpoint_path": str(args.checkpoint.resolve()), "verified_files": verified,
+              "limits": ["Two recorded single-linkage inputs only; no general raw-WURCS conversion or corpus parity.",
+                         "Physical modalities are explicitly absent; their active paths and residue/multitoken fallback are untested.",
+                         "This is CPU inference, not a historical CUDA numerical replay or a model-quality estimate.",
+                         "Original component/model guards are retained. Training/static-release launch bootstrap is outside this inference scope."]}
+    try:
+        import numpy as np
+        import torch
+        torch.set_num_threads(args.threads)
+        torch.set_num_interop_threads(1)
+        report["runtime"] = {"python": platform.python_version(), "torch": torch.__version__, "numpy": np.__version__,
+                             "device": "cpu", "precision": "float32", "threads": args.threads, "host": platform.node()}
+        report["phase"] = "strict_full_checkpoint_load"
+        model, bindings = load_model(args.checkpoint, config, source)
+        report["full_model"] = {"state_entries": len(model.state_dict()), "parameters": sum(p.numel() for p in model.parameters()),
+                                "strict_load": True, "checkpoint_sha256": config["checkpoint"]["sha256"],
+                                "component_authorities": bindings}
+        report["phase"] = "two_recorded_case_inference_and_reference_comparison"
+        report.update(run_cases(model, records, config, readout, output))
+        report["status"] = "PASS_PORTABLE_FULL_WA3_TWO_CASE_REFERENCE_CHECK"
+    except (Exception, SystemExit) as error:
+        report["status"] = "FAIL"
+        report["error"] = type(error).__name__ + ": " + str(error)
+        raise
+    finally:
+        report["finished_unix"] = time.time()
+        with (output / "inference_report.json").open("x") as handle:
+            json.dump(report, handle, indent=2, allow_nan=False)
+            handle.write("\n")
+    print(json.dumps({"status": report["status"], "report": str(output / "inference_report.json")}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

releases/2026-10-02/iar_inference/original_inference_helpers.py

@@ -0,0 +1,97 @@
+"""Verbatim selected functions from the hash-bound final IAR source.
+
+Only these inference helpers are copied. The original module's import-time open
+replacement, Nova paths, fitting functions and main() are not imported or run.
+See config.json for the original source pin and helper names.
+"""
+import torch
+
+HOOK = {"mask": None, "vec": None}
+CAP = {"h": None}
+
+def fail(msg: str):
+    raise SystemExit("FAIL-CLOSED: " + msg)
+
+
+def all_absent(B, dev):  # contract from iar_bytype3_20260825_r1/bytype.py (job 12094273)
+    return {"ms_token_ids": torch.empty((0, 64), dtype=torch.long, device=dev),
+            "ms_attention_mask": torch.zeros((0, 64), dtype=torch.bool, device=dev),
+            "ms_input_mask": torch.zeros((0, 64), dtype=torch.bool, device=dev), "ms_labels": None,
+            "ms_acquisition_parent_indices": torch.empty((0,), dtype=torch.long, device=dev),
+            "ms_parent_available": torch.zeros((B,), dtype=torch.bool, device=dev), "ms_mode": "development",
+            "static_token_ids": torch.zeros((B, 1, 4), dtype=torch.long, device=dev),
+            "static_attention_mask": torch.zeros((B, 1, 4), dtype=torch.bool, device=dev),
+            "static_residue_ids": torch.full((B, 1, 4), -1, dtype=torch.long, device=dev),
+            "static_slot_ids": torch.full((B, 1, 4), -1, dtype=torch.long, device=dev),
+            "static_state_mask": torch.zeros((B, 1), dtype=torch.bool, device=dev),
+            "static_state_ids": torch.full((B, 1), -1, dtype=torch.long, device=dev),
+            "static_input_mask": torch.zeros((B, 1, 4), dtype=torch.bool, device=dev), "static_labels": None,
+            "static_parent_available": torch.zeros((B,), dtype=torch.bool, device=dev),
+            "md_values": torch.zeros((B, 2, 20, 6), dtype=torch.float32, device=dev),
+            "md_feature_mask": torch.zeros((B, 2, 20, 6), dtype=torch.bool, device=dev),
+            "md_child_present_mask": torch.zeros((B, 2), dtype=torch.bool, device=dev),
+            "md_state_row_ids": torch.full((B, 2), -1, dtype=torch.long, device=dev),
+            "md_window_input_mask": torch.zeros((B, 2, 20), dtype=torch.bool, device=dev), "md_labels": None,
+            "md_parent_available": torch.zeros((B,), dtype=torch.bool, device=dev)}
+
+
+def _linkage_hook(module, inputs, output):
+    m = HOOK["mask"]
+    if m is None:
+        return None
+    if output.dim() == 3 and tuple(output.shape[:2]) == tuple(m.shape):
+        idx = m
+    elif output.dim() == 2 and output.shape[0] == m.numel():
+        idx = m.reshape(-1)
+    else:
+        fail("linkage embedding output %s does not match mask %s" % (tuple(output.shape), tuple(m.shape)))
+    out = output.clone()
+    out[idx] = HOOK["vec"].to(out.dtype)
+    return out
+
+
+def find_linkage_embedding(model):
+    cands = [(n, m) for n, m in model.named_modules() if isinstance(m, torch.nn.Embedding) and m.num_embeddings == 10]
+    named = [(n, m) for n, m in cands if "linkage" in n.lower()]
+    if len(named) != 1:
+        fail("linkage embedding not unique: %s" % [n for n, _ in cands])
+    return named[0]
+
+
+def _cap_hook(module, inputs, output):
+    CAP["h"] = inputs[0].detach()
+
+
+def find_lm_projection(model):
+    cands = [(n, m) for n, m in model.named_modules() if isinstance(m, torch.nn.Linear) and m.out_features == 2114]
+    if len(cands) > 1:
+        pref = [(n, m) for n, m in cands if any(k in n.lower() for k in ("seq", "mlm", "lm_", "sequence"))]
+        cands = pref if len(pref) == 1 else cands
+    if len(cands) != 1:
+        fail("LM projection not unique: %s" % [n for n, _ in cands])
+    return cands[0]
+
+
+def _gather_h(B, L, bi, pos):
+    H = CAP["h"]
+    if H.dim() == 3 and H.shape[0] == B and H.shape[1] == L:
+        return H[bi, pos]
+    if H.dim() == 2 and H.shape[0] == B * L:
+        return H.reshape(B, L, -1)[bi, pos]
+    fail("unexpected LM-projection input shape %s for batch %d x %d" % (tuple(H.shape), B, L))
+
+
+def _forward(model, dev, tok, am, rid, bd, lt, neutral_pos):
+    HOOK["mask"] = None
+    if neutral_pos is not None:
+        m = torch.zeros(tok.shape, dtype=torch.bool)
+        for bi, p in neutral_pos:
+            m[bi, p] = True
+        HOOK["mask"] = m.to(dev)
+    with torch.inference_mode():
+        o = model(seq_token_ids=tok.to(dev), seq_attention_mask=am.bool().to(dev), seq_residue_ids=rid.to(dev),
+                  seq_branch_depths=bd.to(dev), seq_linkage_types=lt.to(dev),
+                  seq_labels=None, topology_labels=None, topology_available=None,
+                  **all_absent(tok.shape[0], torch.device(dev)))
+    HOOK["mask"] = None
+    return o.sequence_logits.float()

releases/2026-10-02/iar_inference/preparation_validation.json

@@ -0,0 +1,17 @@
+{
+  "schema": "iar_portable_preparation_validation_v1",
+  "status": "PASS_PREPARATION_ONLY_FULL_FORWARD_PENDING",
+  "checked_at_utc": "2026-09-30T21:33:17.598488+00:00",
+  "python": "3.12.4",
+  "syntax": "PASS_2_PYTHON_FILES",
+  "small_file_preflight": "PASS",
+  "verified_files": 24,
+  "recorded_cases": 2,
+  "helper_ast_equivalence": "PASS_8_FUNCTIONS",
+  "negative_integrity_check": "PASS_CHANGED_FIXTURE_PIN_REJECTED",
+  "checkpoint_loaded": false,
+  "model_constructed": false,
+  "model_forward_executed": false,
+  "remote_contact": false,
+  "limit": "This receipt validates source/fixture preparation only. Require the independent full-model portable smoke receipt before calling portable inference verified."
+}

releases/2026-10-02/iar_inference/requirements.txt

@@ -0,0 +1,3 @@
+# Executed CPU reference versions (Python 3.10.16).
+numpy==2.2.6
+torch==2.9.1

releases/2026-10-02/notebooks/BERTose_workbench.ipynb

@@ -0,0 +1,583 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f77c7ed4",
+   "metadata": {},
+   "source": [
+    "# BERTose workbench\n",
+    "\n",
+    "Turn WURCS 2.0 glycans into 768-dimensional sequence embeddings, inspect similarity, make a small PCA plot, and export data for your own analysis or application.\n",
+    "\n",
+    "This notebook uses the released **variant 3** encoder. You can choose variants 1–5. The weights were learned with multimodal supervision; this interface takes WURCS sequence inputs. It does not generate MS, static 3D, or MD inputs.\n",
+    "\n",
+    "A normal **Run All** embeds six shipped examples and checks the small IAR files. Binding and full IAR are separate opt-in sections. Similarity and PCA are exploratory views, with no fitted downstream head or model-quality claim.\n",
+    "\n",
+    "The notebook works in Colab, a local Jupyter kernel, or a backend Python environment. Start with a CPU kernel and allow memory for the encoder and activations. Downloads use public Hugging Face repositories; no token is needed for public access."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "86a15c72",
+   "metadata": {},
+   "source": [
+    "## 1. Get the versioned code\n",
+    "\n",
+    "The bootstrap downloads only `releases/2026-10-02/**` from the Hugging Face code repository. It does not fetch its older code tree or model weights.\n",
+    "\n",
+    "For an existing checkout, set `BERTose_CODE_DIR` to the directory containing `bertose_workbench.py`. For offline use, also set `BERTose_OFFLINE=1`, `BERTose_INSTALL=0`, and `BERTose_CHECKPOINT` to your downloaded variant checkpoint before starting the kernel. The offline path never installs packages or downloads files. Dependencies must already be available.\n",
+    "\n",
+    "You can pin code and encoder commits with `BERTose_CODE_REVISION` and `BERTose_ENCODER_REVISION`. A code snapshot and the selected encoder's hash checks provide separate provenance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "07f338df",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import sys\n",
+    "import subprocess\n",
+    "import importlib.util\n",
+    "from pathlib import Path\n",
+    "\n",
+    "OFFLINE = os.environ.get(\"BERTose_OFFLINE\", \"0\") == \"1\"\n",
+    "INSTALL_DEPENDENCIES = os.environ.get(\"BERTose_INSTALL\", \"1\") == \"1\" and not OFFLINE\n",
+    "CODE_REVISION = os.environ.get(\"BERTose_CODE_REVISION\", \"main\")\n",
+    "ENCODER_REVISION = os.environ.get(\"BERTose_ENCODER_REVISION\", \"main\")\n",
+    "CODE_REPO = \"supanthadey1/bertose-affinose-training-code\"\n",
+    "RELEASE_PATH = \"releases/2026-10-02\"\n",
+    "\n",
+    "local_code = os.environ.get(\"BERTose_CODE_DIR\")\n",
+    "if local_code:\n",
+    "    CODE_DIR = Path(local_code).expanduser().resolve()\n",
+    "else:\n",
+    "    # A notebook opened from its downloaded code/notebooks folder can reuse it.\n",
+    "    candidates = (Path.cwd(), Path.cwd().parent)\n",
+    "    CODE_DIR = next((p.resolve() for p in candidates if (p / \"bertose_workbench.py\").is_file()), None)\n",
+    "    if CODE_DIR is None:\n",
+    "        if OFFLINE:\n",
+    "            raise RuntimeError(\"Offline: set BERTose_CODE_DIR to the downloaded code directory.\")\n",
+    "        if importlib.util.find_spec(\"huggingface_hub\") is None:\n",
+    "            if not INSTALL_DEPENDENCIES:\n",
+    "                raise ImportError(\"Install huggingface_hub or set BERTose_CODE_DIR to local code.\")\n",
+    "            subprocess.run([sys.executable, \"-m\", \"pip\", \"install\", \"huggingface_hub>=1.1,<2\"], check=True)\n",
+    "        from huggingface_hub import snapshot_download\n",
+    "        snapshot = Path(snapshot_download(\n",
+    "            repo_id=CODE_REPO, repo_type=\"model\", revision=CODE_REVISION,\n",
+    "            allow_patterns=[f\"{RELEASE_PATH}/**\"],\n",
+    "        ))\n",
+    "        CODE_DIR = snapshot / RELEASE_PATH\n",
+    "\n",
+    "if not (CODE_DIR / \"bertose_workbench.py\").is_file():\n",
+    "    raise FileNotFoundError(f\"The workbench module is absent from {CODE_DIR}. Check the release revision.\")\n",
+    "sys.path.insert(0, str(CODE_DIR))\n",
+    "sys.dont_write_bytecode = True\n",
+    "print(\"Code directory:\", CODE_DIR)\n",
+    "print(\"Offline:\", OFFLINE, \"| package installation:\", INSTALL_DEPENDENCIES)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b53e279",
+   "metadata": {},
+   "source": [
+    "## 2. Prepare the environment\n",
+    "\n",
+    "The following cell installs `requirements-workbench.txt` in the current kernel's Python when installation is enabled. That file adds Hugging Face access, plotting and notebook support to the encoder dependencies. Restart the kernel if Jupyter requests it after an installation. Installation errors stop the run."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffe5b4ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if INSTALL_DEPENDENCIES:\n",
+    "    subprocess.run([\n",
+    "        sys.executable, \"-m\", \"pip\", \"install\", \"-r\",\n",
+    "        str(CODE_DIR / \"requirements-workbench.txt\"),\n",
+    "    ], check=True)\n",
+    "else:\n",
+    "    print(\"Using the current environment; no packages installed.\")\n",
+    "\n",
+    "import csv\n",
+    "import json\n",
+    "import time\n",
+    "import shlex\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "import matplotlib.pyplot as plt\n",
+    "from bertose_workbench import Encoder, cosine_similarity, nearest_neighbors, pca\n",
+    "\n",
+    "torch.set_num_threads(4)\n",
+    "VARIANT = \"3\"\n",
+    "DEVICE = \"cpu\"  # Change to \"cuda\" only in a suitable local runtime.\n",
+    "BATCH_SIZE = 8\n",
+    "checkpoint_env = os.environ.get(\"BERTose_CHECKPOINT\")\n",
+    "LOCAL_CHECKPOINT = Path(checkpoint_env).expanduser().resolve() if checkpoint_env else None\n",
+    "if OFFLINE and LOCAL_CHECKPOINT is None:\n",
+    "    raise RuntimeError(\"Offline: set BERTose_CHECKPOINT to the downloaded variant-3 sequence_encoder.pt.\")\n",
+    "\n",
+    "run_name = time.strftime(\"run_%Y%m%d_%H%M%S\") + f\"_{time.time_ns() % 1_000_000:06d}\"\n",
+    "OUTPUT_DIR = Path(os.environ.get(\"BERTose_OUTPUT_DIR\", str(Path.cwd() / \"bertose_outputs\" / run_name))).expanduser().resolve()\n",
+    "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "ASSETS_DIR = Path(os.environ.get(\"BERTose_ASSETS_DIR\", str(Path.cwd() / \"bertose_assets\"))).expanduser().resolve()\n",
+    "print({\"python\": sys.version.split()[0], \"torch\": torch.__version__, \"numpy\": np.__version__,\n",
+    "       \"variant\": VARIANT, \"device\": DEVICE, \"batch_size\": BATCH_SIZE, \"threads\": torch.get_num_threads()})\n",
+    "print(\"Results:\", OUTPUT_DIR)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8d734d5",
+   "metadata": {},
+   "source": [
+    "## 3. Load once, then embed batches\n",
+    "\n",
+    "`Encoder.from_pretrained` retrieves the selected sequence export from Hugging Face and verifies it against the release manifest. Supply `local_checkpoint=...` to use an existing file. The same API is usable in a Python script or backend service; load the encoder once per worker.\n",
+    "\n",
+    "`pooling=\"first\"` returns the START-envelope token state. `pooling=\"mean\"` averages all attended states, including START and END. These are representation choices, not trained binding scores."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d2339c0d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "encoder = Encoder.from_pretrained(\n",
+    "    variant=VARIANT,\n",
+    "    revision=ENCODER_REVISION,\n",
+    "    device=DEVICE,\n",
+    "    local_checkpoint=LOCAL_CHECKPOINT,\n",
+    ")\n",
+    "print(\"Encoder loaded.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f45afc6",
+   "metadata": {},
+   "source": [
+    "## 4. Six real release inputs\n",
+    "\n",
+    "The first two WURCS strings come from `examples/glycans.csv`. Four distinct glycans come from the released held-out binding example CSVs. We keep their file and row provenance; these six examples are a demonstration, not a representative evaluation set.\n",
+    "\n",
+    "To try your own glycans, set `CUSTOM_SAMPLES` below to a list of dictionaries containing unique `sample_id` and `wurcs` strings. A single glycan is also supported; the notebook skips nearest-neighbor and PCA views until there are two or more inputs. Use WURCS 2.0, not IUPAC names or protein sequences. Inspect unknown-token and tree-channel diagnostics. The loader rejects overlength inputs rather than truncating them."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1f36c033",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "CUSTOM_SAMPLES = None  # Replace None with your list of sample_id/wurcs dictionaries.\n",
+    "samples = []\n",
+    "if CUSTOM_SAMPLES is None:\n",
+    "    seen_wurcs = set()\n",
+    "    example_sources = [\n",
+    "        (\"examples/glycans.csv\", \"wurcs\"),\n",
+    "        (\"bertosebind_inference/examples/glycan_cold.csv\", \"glycan_wurcs\"),\n",
+    "        (\"bertosebind_inference/examples/protein_cold.csv\", \"glycan_wurcs\"),\n",
+    "    ]\n",
+    "    for relative_path, wurcs_column in example_sources:\n",
+    "        with (CODE_DIR / relative_path).open(newline=\"\") as handle:\n",
+    "            for source_row, row in enumerate(csv.DictReader(handle), start=2):\n",
+    "                if row[wurcs_column] not in seen_wurcs:\n",
+    "                    seen_wurcs.add(row[wurcs_column])\n",
+    "                    samples.append({\n",
+    "                        \"sample_id\": row[\"sample_id\"], \"wurcs\": row[wurcs_column],\n",
+    "                        \"source_file\": relative_path, \"source_csv_row\": source_row,\n",
+    "                    })\n",
+    "    assert len(samples) == 6\n",
+    "else:\n",
+    "    samples = list(CUSTOM_SAMPLES)\n",
+    "if not samples:\n",
+    "    raise ValueError(\"Provide at least one glycan input.\")\n",
+    "if any(not row.get(\"sample_id\") for row in samples) or len({row[\"sample_id\"] for row in samples}) != len(samples):\n",
+    "    raise ValueError(\"Samples require unique, nonempty sample_id values.\")\n",
+    "for row in samples:\n",
+    "    print(row[\"sample_id\"], \"\\n \", row[\"wurcs\"], \"\\n  source:\", row.get(\"source_file\", \"custom input\"),\n",
+    "          \"row\", row.get(\"source_csv_row\", \"\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1114f6ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wurcs = [row[\"wurcs\"] for row in samples]\n",
+    "vectors, diagnostics = encoder.encode_with_diagnostics(\n",
+    "    wurcs, batch_size=BATCH_SIZE, pooling=\"first\",\n",
+    ")\n",
+    "assert vectors.shape == (len(samples), 768) and np.isfinite(vectors).all()\n",
+    "print(\"Embedding shape:\", vectors.shape, \"| dtype:\", vectors.dtype)\n",
+    "for row, diagnostic in zip(samples, diagnostics):\n",
+    "    print(row[\"sample_id\"], diagnostic)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1006eff2",
+   "metadata": {},
+   "source": [
+    "## 5. Compare representations\n",
+    "\n",
+    "A cosine value describes direction in this representation space. It is not a binding probability, chemical-equivalence test, or validated biological distance. Here the query is the second shipped example and its reference pool excludes the query itself."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "712c2527",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "similarity = cosine_similarity(vectors, vectors)\n",
+    "assert similarity.shape == (len(samples), len(samples))\n",
+    "print(\"Cosine matrix (rows/columns follow samples):\")\n",
+    "print(np.array2string(similarity, precision=4))\n",
+    "\n",
+    "neighbor_rows = []\n",
+    "query_index = min(1, len(samples) - 1)\n",
+    "reference_indices = np.asarray([i for i in range(len(samples)) if i != query_index])\n",
+    "if len(reference_indices):\n",
+    "    neighbor_indices, neighbor_scores = nearest_neighbors(\n",
+    "        vectors[query_index:query_index + 1], vectors[reference_indices], k=min(3, len(reference_indices)),\n",
+    "    )\n",
+    "    neighbor_rows = [{\n",
+    "        \"query_id\": samples[query_index][\"sample_id\"], \"rank\": rank + 1,\n",
+    "        \"neighbor_id\": samples[int(reference_indices[neighbor])][\"sample_id\"],\n",
+    "        \"cosine\": float(score),\n",
+    "    } for rank, (neighbor, score) in enumerate(zip(neighbor_indices[0], neighbor_scores[0]))]\n",
+    "    for row in neighbor_rows:\n",
+    "        print(row)\n",
+    "else:\n",
+    "    print(\"Nearest neighbors need at least two inputs; the single embedding is ready.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3bf46f04",
+   "metadata": {},
+   "source": [
+    "## 6. A small exploratory PCA view\n",
+    "\n",
+    "PCA is fit only on these six embeddings. The plotted axes and neighborhoods change when the input set or pooling changes. This plot does not measure downstream performance or establish glycan classes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b97028b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coordinates = None\n",
+    "if len(samples) >= 2:\n",
+    "    coordinates = pca(vectors, n_components=2)\n",
+    "    assert coordinates.shape == (len(samples), 2) and np.isfinite(coordinates).all()\n",
+    "    fig, (ax, key_ax) = plt.subplots(1, 2, figsize=(10, 5), gridspec_kw={\"width_ratios\": [3, 2]})\n",
+    "    ax.scatter(coordinates[:, 0], coordinates[:, 1], s=60, color=\"#4C78A8\")\n",
+    "    for i, row in enumerate(samples):\n",
+    "        ax.annotate(str(i + 1), coordinates[i], xytext=(5, 5), textcoords=\"offset points\", fontsize=10)\n",
+    "    ax.set(xlabel=\"PC 1\", ylabel=\"PC 2\")\n",
+    "    ax.grid(alpha=0.2)\n",
+    "    key_ax.axis(\"off\")\n",
+    "    key_ax.text(0.0, 0.95, \"Sample key\", va=\"top\", fontsize=11, fontweight=\"bold\")\n",
+    "    key_ax.text(0.0, 0.85, \"\\n\".join(f\"{i + 1}. {row['sample_id']}\" for i, row in enumerate(samples)),\n",
+    "                va=\"top\", fontsize=9, linespacing=1.8)\n",
+    "    key_ax.text(0.0, 0.25, \"Exploratory representation view\", fontsize=9, color=\"0.35\")\n",
+    "    fig.suptitle(f\"{len(samples)} glycan inputs · variant {VARIANT} · first-token pooling\", fontsize=13)\n",
+    "    fig.tight_layout(rect=[0, 0, 1, 0.95])\n",
+    "    fig.savefig(OUTPUT_DIR / \"pca.png\", dpi=180, bbox_inches=\"tight\")\n",
+    "    plt.show()\n",
+    "else:\n",
+    "    print(\"A two-axis PCA view needs at least two inputs; the single embedding is ready.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f1ee2c41",
+   "metadata": {},
+   "source": [
+    "## 7. Save inputs, vectors and provenance\n",
+    "\n",
+    "The NPZ stores all 768 columns plus sample IDs and WURCS. CSV files store the same vectors, PCA coordinates and nearest neighbors. A JSON sidecar records the selected settings, input provenance and diagnostics. These files can be read by another notebook or a backend collaborator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d24de9e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_csv = OUTPUT_DIR / \"glycans.csv\"\n",
+    "with input_csv.open(\"w\", newline=\"\") as handle:\n",
+    "    writer = csv.DictWriter(handle, fieldnames=[\"sample_id\", \"wurcs\"])\n",
+    "    writer.writeheader()\n",
+    "    writer.writerows({k: row[k] for k in writer.fieldnames} for row in samples)\n",
+    "\n",
+    "np.savez_compressed(\n",
+    "    OUTPUT_DIR / \"embeddings.npz\",\n",
+    "    sample_id=np.asarray([row[\"sample_id\"] for row in samples]),\n",
+    "    wurcs=np.asarray(wurcs), embeddings=vectors,\n",
+    ")\n",
+    "with (OUTPUT_DIR / \"embeddings.csv\").open(\"w\", newline=\"\") as handle:\n",
+    "    writer = csv.writer(handle)\n",
+    "    writer.writerow([\"sample_id\"] + [f\"embedding_{i}\" for i in range(vectors.shape[1])])\n",
+    "    writer.writerows([row[\"sample_id\"], *vector.tolist()] for row, vector in zip(samples, vectors))\n",
+    "if coordinates is not None:\n",
+    "    with (OUTPUT_DIR / \"pca.csv\").open(\"w\", newline=\"\") as handle:\n",
+    "        writer = csv.writer(handle)\n",
+    "        writer.writerow([\"sample_id\", \"pc1\", \"pc2\"])\n",
+    "        writer.writerows([row[\"sample_id\"], *point.tolist()] for row, point in zip(samples, coordinates))\n",
+    "with (OUTPUT_DIR / \"neighbors.csv\").open(\"w\", newline=\"\") as handle:\n",
+    "    writer = csv.DictWriter(handle, fieldnames=[\"query_id\", \"rank\", \"neighbor_id\", \"cosine\"])\n",
+    "    writer.writeheader()\n",
+    "    writer.writerows(neighbor_rows)\n",
+    "\n",
+    "run_metadata = {\n",
+    "    \"code_repo\": CODE_REPO, \"code_revision_requested\": CODE_REVISION, \"code_dir\": str(CODE_DIR),\n",
+    "    \"encoder_revision_requested\": ENCODER_REVISION, \"variant\": VARIANT, \"device\": DEVICE,\n",
+    "    \"checkpoint\": str(encoder.checkpoint), \"encoder_metadata\": encoder.metadata,\n",
+    "    \"pooling\": \"first\", \"batch_size\": BATCH_SIZE, \"shape\": list(vectors.shape),\n",
+    "    \"samples\": samples, \"diagnostics\": diagnostics,\n",
+    "    \"scope\": \"Sequence embeddings and exploratory views; no fitted task head or benchmark evaluation.\",\n",
+    "}\n",
+    "(OUTPUT_DIR / \"run.json\").write_text(json.dumps(run_metadata, indent=2, allow_nan=False) + \"\\n\")\n",
+    "reloaded = np.load(OUTPUT_DIR / \"embeddings.npz\", allow_pickle=False)\n",
+    "assert np.array_equal(reloaded[\"embeddings\"], vectors)\n",
+    "print(\"Wrote:\", \", \".join(sorted(p.name for p in OUTPUT_DIR.iterdir())))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d1fee9ab",
+   "metadata": {},
+   "source": [
+    "## 8. Reuse the API in an application\n",
+    "\n",
+    "This is an ordinary Python function: adapt its dictionary response to your web framework. The shared `encoder` is already loaded. Preserve diagnostics and model settings in application outputs. Do not call `from_pretrained` for every request."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "25b08f63",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def embed_records(records, pooling=\"first\"):\n",
+    "    matrix, info = encoder.encode_with_diagnostics(\n",
+    "        [row[\"wurcs\"] for row in records], batch_size=BATCH_SIZE, pooling=pooling,\n",
+    "    )\n",
+    "    return {\n",
+    "        \"variant\": VARIANT, \"pooling\": pooling, \"dimensions\": int(matrix.shape[1]),\n",
+    "        \"results\": [{\"sample_id\": row[\"sample_id\"], \"embedding\": vector.tolist(), \"diagnostics\": diagnostic}\n",
+    "                    for row, vector, diagnostic in zip(records, matrix, info)],\n",
+    "    }\n",
+    "\n",
+    "# One real request, using mean pooling to demonstrate the alternative.\n",
+    "api_response = embed_records(samples[:1], pooling=\"mean\")\n",
+    "assert len(api_response[\"results\"][0][\"embedding\"]) == 768\n",
+    "print({\"variant\": api_response[\"variant\"], \"pooling\": api_response[\"pooling\"],\n",
+    "       \"dimensions\": api_response[\"dimensions\"], \"sample_id\": api_response[\"results\"][0][\"sample_id\"],\n",
+    "       \"diagnostics\": api_response[\"results\"][0][\"diagnostics\"]})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5cf5688a",
+   "metadata": {},
+   "source": [
+    "## 9. Embed an input CSV from the terminal\n",
+    "\n",
+    "`embed.py` is the released CSV interface. Input columns are `sample_id,wurcs`; sample IDs must be unique. The optional cell below runs it on our saved input and compares its vectors with the API output. The CLI requires a new output path and writes a JSON sidecar. It reuses the already verified checkpoint loaded by the API."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ea4276f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RUN_EMBED_CLI = False  # Set True to execute the CLI demonstration.\n",
+    "if RUN_EMBED_CLI:\n",
+    "    cli_checkpoint = encoder.checkpoint\n",
+    "    cli_output = OUTPUT_DIR / f\"cli_embeddings_{time.time_ns()}.npz\"\n",
+    "    cli_command = [\n",
+    "        sys.executable, str(CODE_DIR / \"embed.py\"), \"--checkpoint\", str(cli_checkpoint),\n",
+    "        \"--variant\", VARIANT, \"--input\", str(input_csv), \"--output\", str(cli_output),\n",
+    "        \"--pooling\", \"first\", \"--batch-size\", str(BATCH_SIZE), \"--device\", DEVICE, \"--threads\", \"4\",\n",
+    "    ]\n",
+    "    print(shlex.join(cli_command))\n",
+    "    subprocess.run(cli_command, check=True, cwd=CODE_DIR)\n",
+    "    cli_vectors = np.load(cli_output, allow_pickle=False)[\"embeddings\"]\n",
+    "    assert np.allclose(cli_vectors, vectors, atol=1e-6, rtol=1e-6)\n",
+    "    print(\"CLI/API embeddings agree.\")\n",
+    "else:\n",
+    "    print(\"CLI example is ready; set RUN_EMBED_CLI=True to run it.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d932e5ba",
+   "metadata": {},
+   "source": [
+    "## 10. Optional: fitted BERToseBind predictions\n",
+    "\n",
+    "Set `RUN_BINDING=True` only when you want to download the fitted checkpoint, eight pinned glycan feature/index files and the **2.33 GB protein HDF5 cache**. The downloader fetches the selected fit, not all nine. The default `mo_A_glycan_s42` uses the glycan-cold example CSV. All supported cell IDs and their regimes are in `bertosebind_inference/config.json`; the cell chooses the matching CSV from that configuration.\n",
+    "\n",
+    "The runnable interface supports pairs already represented in the pinned released glycan features and protein cache. It does not build inputs for arbitrary new proteins/glycans. Its regression score is not a calibrated binding probability or affinity constant. Two example predictions check loading; they do not evaluate model quality.\n",
+    "\n",
+    "To reuse downloaded assets offline, set `BERTose_BINDING_PATHS` to the downloader's `paths_binding.json`. Paths can point outside the notebook folder. This optional section may require `requirements-analysis.txt` (`h5py` and `pandas`); installation stays off in offline mode."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b5397f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RUN_BINDING = False  # Explicit opt-in to the large binding assets and computation.\n",
+    "BINDING_CELL_ID = \"mo_A_glycan_s42\"\n",
+    "binding_config = json.loads((CODE_DIR / \"bertosebind_inference/config.json\").read_text())\n",
+    "if BINDING_CELL_ID not in binding_config[\"checkpoints\"]:\n",
+    "    raise ValueError(\"Choose a cell ID from bertosebind_inference/config.json.\")\n",
+    "regime = binding_config[\"checkpoints\"][BINDING_CELL_ID][\"regime\"]\n",
+    "example_name = {\"test_glycan_cold\": \"glycan_cold.csv\", \"test_protein_cold\": \"protein_cold.csv\",\n",
+    "                \"test_doubly_cold\": \"doubly_cold.csv\"}[regime]\n",
+    "binding_pairs = CODE_DIR / \"bertosebind_inference/examples\" / example_name\n",
+    "\n",
+    "if RUN_BINDING:\n",
+    "    if INSTALL_DEPENDENCIES:\n",
+    "        subprocess.run([sys.executable, \"-m\", \"pip\", \"install\", \"-r\", str(CODE_DIR / \"requirements-analysis.txt\")], check=True)\n",
+    "    binding_paths_file = Path(os.environ.get(\"BERTose_BINDING_PATHS\", str(ASSETS_DIR / \"paths_binding.json\"))).expanduser()\n",
+    "    if not binding_paths_file.is_file():\n",
+    "        if OFFLINE:\n",
+    "            raise FileNotFoundError(\"Offline binding: provide BERTose_BINDING_PATHS with existing assets.\")\n",
+    "        subprocess.run([\n",
+    "            sys.executable, str(CODE_DIR / \"download_assets.py\"), \"--task\", \"binding\",\n",
+    "            \"--cell-id\", BINDING_CELL_ID, \"--output-dir\", str(ASSETS_DIR),\n",
+    "        ], check=True)\n",
+    "    binding_paths = json.loads(binding_paths_file.read_text())\n",
+    "    if binding_paths[\"cell_id\"] != BINDING_CELL_ID:\n",
+    "        raise ValueError(\"The downloaded checkpoint cell ID does not match BINDING_CELL_ID.\")\n",
+    "    binding_output = OUTPUT_DIR / f\"binding_{BINDING_CELL_ID}_{time.time_ns()}.json\"\n",
+    "    binding_command = [\n",
+    "        sys.executable, \"-m\", \"bertosebind_inference.predict\",\n",
+    "        \"--checkpoint\", binding_paths[\"checkpoint\"], \"--cell-id\", BINDING_CELL_ID,\n",
+    "        \"--pairs\", str(binding_pairs), \"--features-dir\", binding_paths[\"features_dir\"],\n",
+    "        \"--protein-h5\", binding_paths[\"protein_h5\"], \"--batch-size\", \"8\", \"--threads\", \"4\",\n",
+    "        \"--output\", str(binding_output),\n",
+    "    ]\n",
+    "    print(shlex.join(binding_command))\n",
+    "    subprocess.run(binding_command, check=True, cwd=CODE_DIR)\n",
+    "    binding_result = json.loads(binding_output.read_text())\n",
+    "    print(\"Status:\", binding_result[\"status\"])\n",
+    "    for prediction in binding_result[\"predictions\"]:\n",
+    "        print({key: prediction[key] for key in (\"sample_id\", \"protein_id\", \"prediction\")})\n",
+    "else:\n",
+    "    print(\"Binding remains off. Selected fit:\", BINDING_CELL_ID, \"| regime:\", regime)\n",
+    "    print(\"Pairs:\", binding_pairs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df1613ea",
+   "metadata": {},
+   "source": [
+    "## 11. Optional: IAR on the two released cases\n",
+    "\n",
+    "The released IAR runner accepts exactly two byte-pinned single-linkage fixtures: one benchmark case and one grey-seal case. Raw WURCS is retained as provenance; the runner does not convert arbitrary user WURCS into new masking cases. It uses the full frozen WA3 checkpoint and saved linkage readout with physical modality carriers absent.\n",
+    "\n",
+    "The small-file preflight below is safe to run with the notebook. It verifies source, metadata and fixture bytes; it does not load the full checkpoint or execute a model forward. Setting `RUN_IAR=True` separately downloads the full checkpoint and runs both recorded cases. Allow several GB of memory. It writes a new result directory and compares hidden features and predictions against the released CPU reference. The report states acceptance or abstention for each case; passing these checks is not completion-accuracy evaluation.\n",
+    "\n",
+    "For offline inference, set `BERTose_IAR_PATHS` to an existing `paths_iar.json` produced by the downloader."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f20a25f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RUN_IAR = False  # Explicit opt-in to the full checkpoint and two model cases.\n",
+    "preflight_command = [sys.executable, str(CODE_DIR / \"iar_inference/infer.py\"), \"--preflight-only\"]\n",
+    "preflight = subprocess.run(preflight_command, check=True, text=True, capture_output=True, cwd=CODE_DIR)\n",
+    "print(preflight.stdout)\n",
+    "\n",
+    "if RUN_IAR:\n",
+    "    iar_paths_file = Path(os.environ.get(\"BERTose_IAR_PATHS\", str(ASSETS_DIR / \"paths_iar.json\"))).expanduser()\n",
+    "    if not iar_paths_file.is_file():\n",
+    "        if OFFLINE:\n",
+    "            raise FileNotFoundError(\"Offline IAR: provide BERTose_IAR_PATHS with the existing full checkpoint.\")\n",
+    "        subprocess.run([\n",
+    "            sys.executable, str(CODE_DIR / \"download_assets.py\"), \"--task\", \"iar\",\n",
+    "            \"--output-dir\", str(ASSETS_DIR),\n",
+    "        ], check=True)\n",
+    "    iar_paths = json.loads(iar_paths_file.read_text())\n",
+    "    iar_output = OUTPUT_DIR / f\"iar_two_cases_{time.time_ns()}\"\n",
+    "    iar_command = [\n",
+    "        sys.executable, str(CODE_DIR / \"iar_inference/infer.py\"),\n",
+    "        \"--checkpoint\", iar_paths[\"checkpoint\"], \"--output-dir\", str(iar_output), \"--threads\", \"4\",\n",
+    "    ]\n",
+    "    print(shlex.join(iar_command))\n",
+    "    subprocess.run(iar_command, check=True, cwd=CODE_DIR)\n",
+    "    iar_result = json.loads((iar_output / \"inference_report.json\").read_text())\n",
+    "    print(\"Status:\", iar_result[\"status\"])\n",
+    "    for case in iar_result[\"cases\"]:\n",
+    "        print({key: case[key] for key in (\"dataset\", \"case_id\", \"final_token\", \"abstained\")})\n",
+    "else:\n",
+    "    print(\"Full IAR remains off; only the small-file preflight ran.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa091d22",
+   "metadata": {},
+   "source": [
+    "## Continue with your inputs\n",
+    "\n",
+    "- Start with a small WURCS list, inspect diagnostics, then increase the batch size according to memory.\n",
+    "- Keep pooling and encoder variant fixed when comparing vectors. Build a reference matrix once and reuse `nearest_neighbors(query_vectors, reference_vectors, k=...)`.\n",
+    "- Use `embeddings.npz` for analysis and `embed_records` for an application response. For a CSV pipeline, use the executed `embed.py` interface above.\n",
+    "- Use the separate binding and IAR package READMEs for their fixed-input contracts. The embedding API supports new WURCS inputs; the shipped binding/IAR examples have narrower input support."
+   ]
+  }
+ ],
+ "metadata": {
+  "bertose_workbench": {
+   "default_batch_size": 8,
+   "default_device": "cpu",
+   "default_threads": 4,
+   "distributed_outputs": "stripped",
+   "release": "2026-10-02"
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

releases/2026-10-02/provenance/WA3_checkpoint_index.json

@@ -0,0 +1 @@
+{"cell_id":"A1111","generation":73,"index_sha256":"249bcca15c06644843070cd47c1d62520d2b5cf00e9533ed65311227040ead33","roles":{"best":{"development_loss":0.38572948901364407,"epoch":58,"filename":"review_md20x6_checkpoint_best.pt","sha256":"8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82"},"latest":{"development_loss":0.385906232017773,"epoch":73,"filename":"review_md20x6_checkpoint_latest.pt","sha256":"1a2d27f26d585ffedf67518f3fc769e9be1c71d5943a8d0c9ae3f75d7dd62f30"},"milestones":{"25":{"development_loss":0.39812925026342416,"epoch":25,"filename":"review_md20x6_checkpoint_milestone_025.pt","sha256":"08f5e9e744edbc555191949ddc56fc6d793d61572e0bee434eb50135f539e790"},"50":{"development_loss":0.38745878758199537,"epoch":50,"filename":"review_md20x6_checkpoint_milestone_050.pt","sha256":"1026b01bb50beaaaaa30354eb7b2bcd5307d82689f1f38a4b6d382b1e3b77ffa"}}},"run_identity_sha256":"55dd7ff33d2196cb1da5e215adb79b0880249f8f1e8c541a7fe36f5759c369d5","schema":"bertose_review_md_temporal_20x6_checkpoint_index_20260802_r3"}

releases/2026-10-02/provenance/WA3_final_receipt.json

@@ -0,0 +1 @@
+{"development_history":[{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.22662700572537933,"ms":0.8557433197062682,"sequence":0.3059137519524717,"static":0.7551767198470175,"topology":0.030460597622770504},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.25215765373639587,"ms":2.5724487456782112,"sequence":1.5196248877762957,"static":2.5891844269759083,"topology":0.06376307786672697},"total_normalized_loss":0.5028213712413956,"weighted_normalized_losses":{"md":0.45325401145075866,"ms":1.7114866394125363,"sequence":0.15295687597623586,"static":0.18879417996175438,"topology":0.007615149405692626}},"epoch":1,"improved":true,"step_identity_chain_sha256":"8349369e088705ef87b62fa7c6ce3541d2dc06f3988bad23622cfab4bf777499"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.2136726617028679,"ms":0.8150696210605691,"sequence":0.23423114401117145,"static":0.6901099233497171,"topology":0.019501219778012342},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2377439390780074,"ms":2.450179599482438,"sequence":1.1635419253299568,"static":2.366097655659455,"topology":0.04082184501436121},"total_normalized_loss":0.47040058466287843,"weighted_normalized_losses":{"md":0.4273453234057358,"ms":1.6301392421211383,"sequence":0.11711557200558573,"static":0.17252748083742928,"topology":0.0048753049445030856}},"epoch":2,"improved":true,"step_identity_chain_sha256":"962391a900077917fa24893d4e57fa974e048d4e7b2f1840019ebb021dea6002"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.20491723994564162,"ms":0.7871846769190306,"sequence":0.19421473235822365,"static":0.6489628202681939,"topology":0.04007295908558098},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.22800217595181557,"ms":2.3663547095553628,"sequence":0.9647606195560059,"static":2.225021486712623,"topology":0.08388460535698647},"total_normalized_loss":0.45071402894938,"weighted_normalized_losses":{"md":0.40983447989128324,"ms":1.5743693538380612,"sequence":0.09710736617911182,"static":0.16224070506704846,"topology":0.010018239771395245}},"epoch":3,"improved":true,"step_identity_chain_sha256":"3aa01b318689b035ac47537fb3364c6b32599626130c2aae40ec5ca10d2f10b1"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.20059318098000678,"ms":0.7833350264236384,"sequence":0.1740526846396435,"static":0.6144367794664927,"topology":0.010871273858649505},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.22319099045385438,"ms":2.3547822808140313,"sequence":0.8646057579123623,"static":2.1066461649905643,"topology":0.022756805041848484},"total_normalized_loss":0.44224195409167955,"weighted_normalized_losses":{"md":0.40118636196001356,"ms":1.5666700528472768,"sequence":0.08702634231982175,"static":0.15360919486662317,"topology":0.002717818464662376}},"epoch":4,"improved":true,"step_identity_chain_sha256":"be59cdbbc21e7f36a63f3d33c56c24586746adb6784ae7c3896a5d797cd60d85"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.19842932505038918,"ms":0.7702185946671242,"sequence":0.16123126231503135,"static":0.5864062674323184,"topology":0.02171640669463639},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.22078336549984892,"ms":2.3153529944347926,"sequence":0.800915412719256,"static":2.010541288699162,"topology":0.04545888915917031},"total_normalized_loss":0.43398842782485625,"weighted_normalized_losses":{"md":0.39685865010077837,"ms":1.5404371893342483,"sequence":0.08061563115751567,"static":0.1466015668580796,"topology":0.005429101673659098}},"epoch":5,"improved":true,"step_identity_chain_sha256":"e90df1029db9d0ff865d415bd64e8e26a458506a2824dd0ed00c2583be939787"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1962911658604727,"ms":0.767122882303372,"sequence":0.15398089224489517,"static":0.5765596184077477,"topology":0.010398237550739037},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21840433214979185,"ms":2.3060469780117274,"sequence":0.7648992390956554,"static":1.9767812565871012,"topology":0.021766599553807216},"total_normalized_loss":0.43011160128795173,"weighted_normalized_losses":{"md":0.3925823317209454,"ms":1.534245764606744,"sequence":0.07699044612244758,"static":0.14413990460193693,"topology":0.0025995593876847593}},"epoch":6,"improved":true,"step_identity_chain_sha256":"842cfd5af25d82c036c7e15af1643caedbf3bb83562d3a55144a041c438a9506"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.194018423453635,"ms":0.7636756649092812,"sequence":0.14634798267436108,"static":0.5698844597821273,"topology":0.0223091175846953},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21587555412079626,"ms":2.295684302829463,"sequence":0.7269828025984444,"static":1.9538949356680038,"topology":0.046699609091960845},"total_normalized_loss":0.4273221124809437,"weighted_normalized_losses":{"md":0.38803684690727,"ms":1.5273513298185624,"sequence":0.07317399133718054,"static":0.14247111494553183,"topology":0.005577279396173825}},"epoch":7,"improved":true,"step_identity_chain_sha256":"7c71e534e6ef7cb575a5ad296663a160fb3f0bcf8d5bbbce2a9596e3ed7174bc"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1930169839550213,"ms":0.7558749452810657,"sequence":0.1399491315920143,"static":0.5620648833879897,"topology":0.00981988587483681},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21476129753199683,"ms":2.272234570928689,"sequence":0.6951965448841485,"static":1.9270848859231555,"topology":0.02055593772104861},"total_normalized_loss":0.4221459233167775,"weighted_normalized_losses":{"md":0.3860339679100426,"ms":1.5117498905621314,"sequence":0.06997456579600715,"static":0.14051622084699741,"topology":0.0024549714687092023}},"epoch":8,"improved":true,"step_identity_chain_sha256":"81ebd06b29d8386df109dbee8ba895db64884466fb61a76a710ee5a3a8ae6fd0"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.19406822581608854,"ms":0.7518932710631684,"sequence":0.1362528402339793,"static":0.5518898818467565,"topology":0.009015226965808379},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21593096696458605,"ms":2.260265265867628,"sequence":0.6768352378023567,"static":1.8921990706660943,"topology":0.018871547634290067},"total_normalized_loss":0.420055138215729,"weighted_normalized_losses":{"md":0.3881364516321771,"ms":1.5037865421263368,"sequence":0.06812642011698965,"static":0.13797247046168912,"topology":0.0022538067414520947}},"epoch":9,"improved":true,"step_identity_chain_sha256":"6812ea9698a1e8fa8242d95e3c4df63df9f536847337f3fdba02ed782dd4e07f"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.19102172991507627,"ms":0.7505529410653496,"sequence":0.13160407793951492,"static":0.548196846882865,"topology":0.007217244018334658},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21254126830066034,"ms":2.256236101815413,"sequence":0.6537425365591589,"static":1.8795372017743697,"topology":0.015107835309843994},"total_normalized_loss":0.4175609807311818,"weighted_normalized_losses":{"md":0.38204345983015253,"ms":1.5011058821306993,"sequence":0.06580203896975746,"static":0.13704921172071624,"topology":0.0018043110045836645}},"epoch":10,"improved":true,"step_identity_chain_sha256":"244f9ebf8f844fdc582f8b77d68d58f852ae14f87ac5110b30ede39a22e546c5"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.19106956913570272,"ms":0.7422393981299115,"sequence":0.12959927503388055,"static":0.5440629670213283,"topology":0.006221932800593297},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21259449684503057,"ms":2.231244772518503,"sequence":0.643783689102829,"static":1.8653638605163814,"topology":0.013024353315681565},"total_normalized_loss":0.41379775940072977,"weighted_normalized_losses":{"md":0.38213913827140544,"ms":1.484478796259823,"sequence":0.06479963751694028,"static":0.13601574175533207,"topology":0.0015554832001483242}},"epoch":11,"improved":true,"step_identity_chain_sha256":"19faa5da708b534a9be44e7b7c20d35f2f66ac5d15d9d680284a7f8b692c7e9f"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.19037402365003858,"ms":0.7366234966393759,"sequence":0.12822089536794967,"static":0.5452088458164462,"topology":0.008232884439421842},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21182059473583295,"ms":2.2143628192359004,"sequence":0.6369365956597113,"static":1.869292598589931,"topology":0.017233872364545984},"total_normalized_loss":0.4112931841653541,"weighted_normalized_losses":{"md":0.38074804730007716,"ms":1.4732469932787517,"sequence":0.06411044768397484,"static":0.13630221145411156,"topology":0.0020582211098554605}},"epoch":12,"improved":true,"step_identity_chain_sha256":"9db8b63da1b78fa49d70078c2a3b87a934a5cf570a6742755f3d6ce00885e1f7"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.19041639201178032,"ms":0.736960530254102,"sequence":0.12604434886221993,"static":0.5334526507395191,"topology":0.005343901317552914},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2118677361021289,"ms":2.215375975493727,"sequence":0.6261246128102991,"static":1.8289855334835847,"topology":0.011186372639271922},"total_normalized_loss":0.41049503139542853,"weighted_normalized_losses":{"md":0.38083278402356063,"ms":1.473921060508204,"sequence":0.06302217443110997,"static":0.13336316268487977,"topology":0.0013359753293882286}},"epoch":13,"improved":true,"step_identity_chain_sha256":"41ffade6ef912d2969b95a2eedcc3a039106187cdbc564b05bb150a4b1926dea"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18864850129010685,"ms":0.7347006251585065,"sequence":0.125190681186743,"static":0.535602107175571,"topology":0.022280826714292268},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2099006837863086,"ms":2.208582478080844,"sequence":0.6218840233066719,"static":1.8363551186209766,"topology":0.04664038789759145},"total_normalized_loss":0.4097528653926128,"weighted_normalized_losses":{"md":0.3772970025802137,"ms":1.469401250317013,"sequence":0.0625953405933715,"static":0.13390052679389275,"topology":0.005570206678573067}},"epoch":14,"improved":true,"step_identity_chain_sha256":"e1fc779a32a5752f26e197664962d6285d2e86d09a0b301734ec06433cfced47"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18932230534558994,"ms":0.7300639699996679,"sequence":0.12059135975771769,"static":0.5375086685680924,"topology":0.005507952683596159},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2106503951861696,"ms":2.194644235768195,"sequence":0.5990369192918266,"static":1.8428919184677595,"topology":0.011529780872974427},"total_normalized_loss":0.4069644771764594,"weighted_normalized_losses":{"md":0.3786446106911799,"ms":1.4601279399993359,"sequence":0.060295679878858845,"static":0.1343771671420231,"topology":0.0013769881708990397}},"epoch":15,"improved":true,"step_identity_chain_sha256":"528261498391f3cb63bf1f013018798661c55d67e76113418f6d2a8c1e4ce07d"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18979667588370328,"ms":0.729257050377908,"sequence":0.1224965826079112,"static":0.5377193858019084,"topology":0.004572563830447886},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21117820590100242,"ms":2.192218555869727,"sequence":0.6085011033680101,"static":1.8436143795367423,"topology":0.009571734185329138},"total_normalized_loss":0.40698574624705347,"weighted_normalized_losses":{"md":0.37959335176740655,"ms":1.458514100755816,"sequence":0.0612482913039556,"static":0.1344298464504771,"topology":0.0011431409576119714}},"epoch":16,"improved":false,"step_identity_chain_sha256":"94ee181ed0af332478fbc91d6850ea1c5b9fb37055d602f6eb92ecb6f393c058"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.19044398384067177,"ms":0.7253422453133344,"sequence":0.12148093259013977,"static":0.5359335464438555,"topology":0.0063599683910022155},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21189843628639551,"ms":2.180450266072976,"sequence":0.6034558674659781,"static":1.837491484943424,"topology":0.013313302804087004},"total_normalized_loss":0.40557726066235933,"weighted_normalized_losses":{"md":0.38088796768134353,"ms":1.4506844906266687,"sequence":0.060740466295069885,"static":0.13398338661096387,"topology":0.0015899920977505539}},"epoch":17,"improved":true,"step_identity_chain_sha256":"accedf095414e081aba3585d10801cc7152637684e6b1e66d3ba0ae439dd611e"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1888921825736983,"ms":0.7306011329012926,"sequence":0.11935736189567756,"static":0.5428638884042807,"topology":0.00425405742116268},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.21017181696628076,"ms":2.1962590003835745,"sequence":0.5929070416689655,"static":1.86125272255306,"topology":0.0089050056717322},"total_normalized_loss":0.4070889596708363,"weighted_normalized_losses":{"md":0.3777843651473966,"ms":1.4612022658025852,"sequence":0.05967868094783878,"static":0.13571597210107017,"topology":0.00106351435529067}},"epoch":18,"improved":false,"step_identity_chain_sha256":"4748dc16e2e0fb741438ffffe8ea67358decacfada7422972ed9de47e448a950"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18853731601049878,"ms":0.7212504073037117,"sequence":0.11723436805777301,"static":0.5373463378322132,"topology":0.00529378593435542},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20977697293752312,"ms":2.1681497977982307,"sequence":0.5823610814037444,"static":1.8423353544181642,"topology":0.011081466257568041},"total_normalized_loss":0.40277053231979,"weighted_normalized_losses":{"md":0.37707463202099756,"ms":1.4425008146074234,"sequence":0.05861718402888651,"static":0.1343365844580533,"topology":0.001323446483588855}},"epoch":19,"improved":true,"step_identity_chain_sha256":"cf9daba2764d8263ffb79ca7f35556d573366151727cab1c57de3eb41a0b6b31"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18732470522153952,"ms":0.7195666013047894,"sequence":0.11674263354679772,"static":0.5369274246652657,"topology":0.00497569131779692},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20842775557280213,"ms":2.1630881110398934,"sequence":0.5799183929129941,"static":1.8408990767633984,"topology":0.010415599748453847},"total_normalized_loss":0.40152594176436446,"weighted_normalized_losses":{"md":0.37464941044307903,"ms":1.4391332026095789,"sequence":0.05837131677339886,"static":0.13423185616631642,"topology":0.00124392282944923}},"epoch":20,"improved":true,"step_identity_chain_sha256":"3528d61e9a4953b6aa0220d8c4b3496d374e71547d7f57b7064f92d2af5b2893"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1876363582716866,"ms":0.7190431341736717,"sequence":0.11718534196001842,"static":0.5390776018521963,"topology":0.004164038808132024},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2087745178734968,"ms":2.1615145172602657,"sequence":0.5821175445315936,"static":1.8482711330534378,"topology":0.008716569978407598},"total_normalized_loss":0.4015524132071616,"weighted_normalized_losses":{"md":0.3752727165433732,"ms":1.4380862683473434,"sequence":0.05859267098000921,"static":0.13476940046304908,"topology":0.001041009702033006}},"epoch":21,"improved":false,"step_identity_chain_sha256":"0478c6e9854ecd9b251c9e213bc36891fa8d4a8b44144d0effcccacf80043cb8"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18783271945591928,"ms":0.715846598873989,"sequence":0.11771536798749985,"static":0.5461228993038463,"topology":0.004379447172740652},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2089930001119332,"ms":2.151905417156502,"sequence":0.5847504459209208,"static":1.872426504856902,"topology":0.009167483663548718},"total_normalized_loss":0.4007683814545427,"weighted_normalized_losses":{"md":0.37566543891183857,"ms":1.431693197747978,"sequence":0.058857683993749924,"static":0.13653072482596157,"topology":0.001094861793185163}},"epoch":22,"improved":true,"step_identity_chain_sha256":"7ee0957a690bf9f5456ca77b9742b292ae6a5c51b43eff3cb19b9bd8cb8f8929"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1871767668245945,"ms":0.7103727853823291,"sequence":0.11628192666514102,"static":0.5459911714081273,"topology":0.0037820487306240874},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20826315118705482,"ms":2.135450594400152,"sequence":0.5776298340009903,"static":1.8719748651185064,"topology":0.007916951292060883},"total_normalized_loss":0.3981366745562211,"weighted_normalized_losses":{"md":0.374353533649189,"ms":1.4207455707646581,"sequence":0.05814096333257051,"static":0.1364977928520318,"topology":0.0009455121826560218}},"epoch":23,"improved":true,"step_identity_chain_sha256":"2c8d3171c46864ec94861d9996b8811b38ba0d322556d6934fce6395b6ff16c0"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18777199994128557,"ms":0.7049079101886564,"sequence":0.11539469749322528,"static":0.5454564029586294,"topology":0.0036034899744572567},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20892544024501863,"ms":2.1190226410483493,"sequence":0.5732225279475711,"static":1.8701413682626205,"topology":0.0075431747820182676},"total_normalized_loss":0.39606442844795364,"weighted_normalized_losses":{"md":0.37554399988257114,"ms":1.4098158203773128,"sequence":0.05769734874661264,"static":0.13636410073965735,"topology":0.0009008724936143142}},"epoch":24,"improved":true,"step_identity_chain_sha256":"f84a0cf966e10855452bfead8481542f5a9b20cde80b2192359d4f8e68cbf4f6"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1869681200818719,"ms":0.7099487995044106,"sequence":0.11643272414371737,"static":0.5502300342311925,"topology":0.00415416605959564},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20803099936147573,"ms":2.134176051070721,"sequence":0.5783789196501185,"static":1.886508148946153,"topology":0.008695903383435295},"total_normalized_loss":0.39812925026342416,"weighted_normalized_losses":{"md":0.3739362401637438,"ms":1.4198975990088212,"sequence":0.058216362071858686,"static":0.13755750855779814,"topology":0.00103854151489891}},"epoch":25,"improved":false,"step_identity_chain_sha256":"51dd88d5d4db95b3b32fbb7ac9b952ca723bf7e2c5eed0fa35fb5b19c05f868c"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18841552983824386,"ms":0.7033956170602036,"sequence":0.11585168737709899,"static":0.5479196650977544,"topology":0.003713389834364146},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2096414669533398,"ms":2.114476538879861,"sequence":0.5754926226934405,"static":1.8785868616187633,"topology":0.0077732278299449085},"total_normalized_loss":0.3958912802436948,"weighted_normalized_losses":{"md":0.3768310596764877,"ms":1.4067912341204072,"sequence":0.05792584368854949,"static":0.1369799162744386,"topology":0.0009283474585910365}},"epoch":26,"improved":true,"step_identity_chain_sha256":"ea75ef4544cd28fed4e054f41bad2fce6f86774be1051c0350b1e433d612ec03"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18669901981477316,"ms":0.7046144276012817,"sequence":0.11363491391429,"static":0.550115956922508,"topology":0.003343397025061905},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20773158362435176,"ms":2.1181404034703455,"sequence":0.564480812655002,"static":1.8861170256721502,"topology":0.006998722989237778},"total_normalized_loss":0.39556183805522943,"weighted_normalized_losses":{"md":0.3733980396295463,"ms":1.4092288552025634,"sequence":0.056817456957145,"static":0.137528989230627,"topology":0.0008358492562654762}},"epoch":27,"improved":true,"step_identity_chain_sha256":"ee247d44c437c3533ebc85d2582f2877b2d1a5562bc2d3391fed073f0ddedfee"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18680978057918643,"ms":0.7027360981756547,"sequence":0.11532498453928958,"static":0.5581590564718851,"topology":0.003439281182740489},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2078548221342156,"ms":2.11249396012261,"sequence":0.5728762292306127,"static":1.9136934426227188,"topology":0.0071994370096243885},"total_normalized_loss":0.3954307668385967,"weighted_normalized_losses":{"md":0.37361956115837286,"ms":1.4054721963513095,"sequence":0.05766249226964479,"static":0.13953976411797128,"topology":0.0008598202956851223}},"epoch":28,"improved":true,"step_identity_chain_sha256":"2e05d67d34765b01db30476b094440885b15faa753286e940942a504e246f993"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18611718220913312,"ms":0.701507074633941,"sequence":0.11576753504756795,"static":0.5507436567855164,"topology":0.0035271283558496297},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20708419914771276,"ms":2.108799394245805,"sequence":0.5750745964572758,"static":1.8882691453911553,"topology":0.007383327234258153},"total_normalized_loss":0.39433999549905474,"weighted_normalized_losses":{"md":0.37223436441826624,"ms":1.403014149267882,"sequence":0.05788376752378398,"static":0.1376859141963791,"topology":0.0008817820889624074}},"epoch":29,"improved":true,"step_identity_chain_sha256":"e34003c15ef687cafdece48f6eb4640a91a8cdb00f0fee6879a58624bb3874f0"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1870041062465378,"ms":0.6952488676497738,"sequence":0.11350901360033186,"static":0.5610069497587966,"topology":0.00359732086848505},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20807103954477196,"ms":2.0899866073552906,"sequence":0.5638554035347891,"static":1.9234576749598256,"topology":0.007530261010944391},"total_normalized_loss":0.3924823044499219,"weighted_normalized_losses":{"md":0.3740082124930756,"ms":1.3904977352995476,"sequence":0.05675450680016593,"static":0.14025173743969915,"topology":0.0008993302171212625}},"epoch":30,"improved":true,"step_identity_chain_sha256":"c94b9d5bf751a42a5761422aa4c67519abfe51e1c3e2ff7b2186a2c1943fcf9b"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18552926299512953,"ms":0.6984604122216393,"sequence":0.11633959795669416,"static":0.5623446920579128,"topology":0.0035183603877805185},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20643004793958472,"ms":2.0996408268102797,"sequence":0.5779163158259982,"static":1.9280442325656804,"topology":0.007364973272932529},"total_normalized_loss":0.39352298250466167,"weighted_normalized_losses":{"md":0.37105852599025907,"ms":1.3969208244432787,"sequence":0.05816979897834708,"static":0.1405861730144782,"topology":0.0008795900969451296}},"epoch":31,"improved":false,"step_identity_chain_sha256":"22a99ec6e93cdfc3b940b0c535e82b51bcbae5e7499d24baf55db94e31432b4d"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18568012430750563,"ms":0.7001969914321841,"sequence":0.11344239058137431,"static":0.5685290688956781,"topology":0.0029350338868824578},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20659790452157764,"ms":2.1048611550431313,"sequence":0.5635244540529155,"static":1.949247868453895,"topology":0.006143897653894644},"total_normalized_loss":0.3942682904931413,"weighted_normalized_losses":{"md":0.37136024861501127,"ms":1.4003939828643681,"sequence":0.05672119529068716,"static":0.14213226722391953,"topology":0.0007337584717206144}},"epoch":32,"improved":false,"step_identity_chain_sha256":"895e2cc888a7f56cd52ea5a37a973da1ff3b308ce4dcf07bfc24318f2c824749"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18579079378983765,"ms":0.6941709269924471,"sequence":0.11519749822068524,"static":0.5661192489833935,"topology":0.004340516875965144},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20672104146598436,"ms":2.0867462115169597,"sequence":0.572242941641004,"static":1.9409856060923543,"topology":0.009085990989786602},"total_normalized_loss":0.39202742642795035,"weighted_normalized_losses":{"md":0.3715815875796753,"ms":1.3883418539848942,"sequence":0.05759874911034262,"static":0.14152981224584837,"topology":0.001085129218991286}},"epoch":33,"improved":true,"step_identity_chain_sha256":"b231fba6226a93658e7564b44fa90e2c690117d8039abd8dc94a481b032eed83"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18593081767416006,"ms":0.693387096507827,"sequence":0.11454659821670357,"static":0.5614319089508184,"topology":0.0031280227162407697},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2068768397302944,"ms":2.084389939839984,"sequence":0.5690095994352639,"static":1.9249146819002751,"topology":0.006547880592974724},"total_normalized_loss":0.39140982207781816,"weighted_normalized_losses":{"md":0.3718616353483201,"ms":1.386774193015654,"sequence":0.057273299108351786,"static":0.1403579772377046,"topology":0.0007820056790601924}},"epoch":34,"improved":true,"step_identity_chain_sha256":"0b9516f1d44359fc25b265efd05b7ea82c1b915b26529bbebba2297c941d81e6"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18653092448192274,"ms":0.6913025012821786,"sequence":0.11700309612352572,"static":0.5737887574360878,"topology":0.003213575276954297},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20754455152462503,"ms":2.0781234411715435,"sequence":0.5812122393367132,"static":1.9672811357695654,"topology":0.006726967512346149},"total_normalized_loss":0.3916837965536452,"weighted_normalized_losses":{"md":0.3730618489638455,"ms":1.3826050025643573,"sequence":0.05850154806176286,"static":0.14344718935902195,"topology":0.0008033938192385742}},"epoch":35,"improved":false,"step_identity_chain_sha256":"6b030e9056e01db69523e77e658de8319eccfcb688835a2ef86bd664004b6e27"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18587856384316986,"ms":0.6880689560718966,"sequence":0.1145185470539755,"static":0.5619452845015106,"topology":0.002963250731657305},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20681869924796725,"ms":2.068403085629488,"sequence":0.5688702554380078,"static":1.9266748314733604,"topology":0.006202963890638041},"total_normalized_loss":0.3892762894330825,"weighted_normalized_losses":{"md":0.37175712768633973,"ms":1.376137912143793,"sequence":0.05725927352698775,"static":0.14048632112537765,"topology":0.0007408126829143262}},"epoch":36,"improved":true,"step_identity_chain_sha256":"665bd47cce5e02ea2ada4e5fdeec90728c96bf663423dd8b62fc65ad4e3336ad"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1855978427576254,"ms":0.6912036318598846,"sequence":0.11474447700890597,"static":0.570678268483088,"topology":0.00325730043461577},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20650635354998365,"ms":2.077826229945339,"sequence":0.569992561252033,"static":1.9566165729649554,"topology":0.006818497254054803},"total_normalized_loss":0.3908918159937798,"weighted_normalized_losses":{"md":0.3711956855152508,"ms":1.3824072637197693,"sequence":0.057372238504452985,"static":0.142669567120772,"topology":0.0008143251086539425}},"epoch":37,"improved":false,"step_identity_chain_sha256":"59e4358eb8cb3989c99ed96be6b743c92a78cef713baf3b8ec4fc200ac5aae21"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18628226273452947,"ms":0.6894950283626093,"sequence":0.11541384521930931,"static":0.5732782976481989,"topology":0.0028644966366610483},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20726787680708206,"ms":2.072689999463358,"sequence":0.5733176441720491,"static":1.9655309831249406,"topology":0.005996242239051097},"total_normalized_loss":0.39065944067502945,"weighted_normalized_losses":{"md":0.37256452546905894,"ms":1.3789900567252187,"sequence":0.057706922609654654,"static":0.14331957441204973,"topology":0.0007161241591652621}},"epoch":38,"improved":false,"step_identity_chain_sha256":"61ac63140ee97daeb11ff0af98b55e2cc266f7784b21723cd60e04ccb26d536e"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18609527192481407,"ms":0.6879375812347679,"sequence":0.11606297331560542,"static":0.5749748418130596,"topology":0.004197018666955648},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20705982056198813,"ms":2.0680081599231426,"sequence":0.5765421844360633,"static":1.9713477219304267,"topology":0.008785606618208533},"total_normalized_loss":0.3901780316193941,"weighted_normalized_losses":{"md":0.37219054384962813,"ms":1.3758751624695358,"sequence":0.05803148665780271,"static":0.1437437104532649,"topology":0.001049254666738912}},"epoch":39,"improved":false,"step_identity_chain_sha256":"14815a131129fdd53c6afacd0ea26e9c7cd5fc479630dad23a4465d2c7273792"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1860477765532129,"ms":0.6861794792469316,"sequence":0.11415070244626119,"static":0.5796372890932975,"topology":0.003095314515184333},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20700697460292886,"ms":2.0627231321008557,"sequence":0.5670429893633404,"static":1.987333299308969,"topology":0.006479412613565053},"total_normalized_loss":0.389442602745108,"weighted_normalized_losses":{"md":0.3720955531064258,"ms":1.3723589584938631,"sequence":0.057075351223130594,"static":0.14490932227332437,"topology":0.0007738286287960833}},"epoch":40,"improved":false,"step_identity_chain_sha256":"f74344ec081ae3f0e76daae3fa24451a0156b680057b368a8667f24b8d407827"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18539234416764283,"ms":0.691727826314129,"sequence":0.11626568618353424,"static":0.5780178487884755,"topology":0.002925738766876558},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20627770453205094,"ms":2.0794020101299573,"sequence":0.5775491594975343,"static":1.9817809173201393,"topology":0.006124440206996961},"total_normalized_loss":0.39152181618882975,"weighted_normalized_losses":{"md":0.37078468833528566,"ms":1.383455652628258,"sequence":0.05813284309176712,"static":0.14450446219711888,"topology":0.0007314346917191395}},"epoch":41,"improved":false,"step_identity_chain_sha256":"eb5126073313a51f4be295e16d8024995dbe9b86e0f5e81a784022c988690245"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18587224769755226,"ms":0.6882215320340647,"sequence":0.11647381389194182,"static":0.58260749159163,"topology":0.003232723529785487},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20681167155744778,"ms":2.068861744006903,"sequence":0.5785830327494342,"static":1.9975168786640176,"topology":0.006767050492706792},"total_normalized_loss":0.39057690403791173,"weighted_normalized_losses":{"md":0.3717444953951045,"ms":1.3764430640681293,"sequence":0.05823690694597091,"static":0.1456518728979075,"topology":0.0008081808824463718}},"epoch":42,"improved":false,"step_identity_chain_sha256":"676e09381467a3e25fd85135dc74b5227bec02e5d64206f5f2a6bf387f1296fd"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18614700269163967,"ms":0.685320170987359,"sequence":0.1171421065871618,"static":0.5920840246162111,"topology":0.002909834056541092},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20711737905439717,"ms":2.060139966794643,"sequence":0.581902773053666,"static":2.030007938152635,"topology":0.006091146924438054},"total_normalized_loss":0.39005077306395325,"weighted_normalized_losses":{"md":0.37229400538327934,"ms":1.370640341974718,"sequence":0.0585710532935809,"static":0.14802100615405278,"topology":0.000727458514135273}},"epoch":43,"improved":false,"step_identity_chain_sha256":"7ff1a9c0e0fa0e04008787607011e553c3d962cca1f1f4cedde45e1761d375b6"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1852961985002174,"ms":0.6863376928436224,"sequence":0.11782033374489713,"static":0.590915873170764,"topology":0.0026635949468924143},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20617072758180918,"ms":2.0631987377631895,"sequence":0.585271862746046,"static":2.026002836497073,"topology":0.005575695332949085},"total_normalized_loss":0.3901145633179085,"weighted_normalized_losses":{"md":0.3705923970004348,"ms":1.372675385687245,"sequence":0.058910166872448565,"static":0.147728968292691,"topology":0.0006658987367231036}},"epoch":44,"improved":false,"step_identity_chain_sha256":"90f8e0e5218cea022036b7b15872317dd62b7769a369c702fa95d2cdf261f6f2"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1852771771014432,"ms":0.6854490128941951,"sequence":0.11695329923316397,"static":0.5881065115506812,"topology":0.0027799599137752775},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20614956332880974,"ms":2.060527278262929,"sequence":0.5809648735565068,"static":2.0163707130943074,"topology":0.0058192817699651645},"total_normalized_loss":0.38953012949479454,"weighted_normalized_losses":{"md":0.3705543542028864,"ms":1.3708980257883903,"sequence":0.058476649616581985,"static":0.1470266278876703,"topology":0.0006949899784438194}},"epoch":45,"improved":false,"step_identity_chain_sha256":"6fc0204c9d72382b80dbc82c884f4ed3bbdd571aa60e6f3d4132bc84032f5c25"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18515215322101983,"ms":0.683250564808573,"sequence":0.11521552646327139,"static":0.5882545155033189,"topology":0.0027547604911359077},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20601045489269165,"ms":2.0539185266781215,"sequence":0.572332496837336,"static":2.0168781566094864,"topology":0.005766531893949943},"total_normalized_loss":0.388433103657887,"weighted_normalized_losses":{"md":0.37030430644203965,"ms":1.366501129617146,"sequence":0.057607763231635696,"static":0.14706362887582972,"topology":0.0006886901227839769}},"epoch":46,"improved":true,"step_identity_chain_sha256":"c05eda781550a7ce7718d4df2fe6c3a7de66cbabd7e25f3d23cb3984b19b4ffa"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18562786327526232,"ms":0.6840400894463337,"sequence":0.11642953551058739,"static":0.5928588482855713,"topology":0.0033916578212694337},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20653975602674077,"ms":2.0562919155405512,"sequence":0.5783630801325048,"static":2.032664483734133,"topology":0.007099747169544423},"total_normalized_loss":0.3893226599450392,"weighted_normalized_losses":{"md":0.37125572655052463,"ms":1.3680801788926673,"sequence":0.058214767755293696,"static":0.14821471207139283,"topology":0.0008479144553173584}},"epoch":47,"improved":false,"step_identity_chain_sha256":"dfa4f9e50c25e779fe20c46465945d19eacc644643045d20d3ce69bbde8abd11"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1847732815355456,"ms":0.6809981609338026,"sequence":0.11489368631824985,"static":0.5954631925978346,"topology":0.0028269217085146654},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20558890144644393,"ms":2.047147578674224,"sequence":0.570733757679195,"static":2.041593688724935,"topology":0.005917586754385115},"total_normalized_loss":0.38771245133488175,"weighted_normalized_losses":{"md":0.3695465630710912,"ms":1.3619963218676052,"sequence":0.057446843159124926,"static":0.14886579814945866,"topology":0.0007067304271286663}},"epoch":48,"improved":true,"step_identity_chain_sha256":"eb398cc6689a6cfc4580944d4217239ae6ef50ca051c458b18128689efdb8d5f"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18503533879837353,"ms":0.6819155163233396,"sequence":0.11916113116360362,"static":0.5977301799585286,"topology":0.00319209553651353},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20588048075018917,"ms":2.0499052393731887,"sequence":0.5919322665818604,"static":2.049366238137805,"topology":0.006682004035948107},"total_normalized_loss":0.38874256893979775,"weighted_normalized_losses":{"md":0.37007067759674706,"ms":1.3638310326466792,"sequence":0.05958056558180181,"static":0.14943254498963215,"topology":0.0007980238841283825}},"epoch":49,"improved":false,"step_identity_chain_sha256":"cf660140247c0497c5db143523d149b00c9d2a00d5a4a95f18df54b57cf0e4cc"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18459828916343385,"ms":0.6798209047768676,"sequence":0.11901937290670442,"static":0.5930596659260227,"topology":0.00272378837806317},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20539419532202496,"ms":2.0436086306573245,"sequence":0.5912280832169188,"static":2.0333530032470546,"topology":0.005701698062322236},"total_normalized_loss":0.38745878758199537,"weighted_normalized_losses":{"md":0.3691965783268677,"ms":1.3596418095537353,"sequence":0.05950968645335221,"static":0.14826491648150567,"topology":0.0006809470945157925}},"epoch":50,"improved":true,"step_identity_chain_sha256":"a1e41959edfb7e58c20e7c6671743081f886539cda2acb274458f70e0d75133b"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18416298638185008,"ms":0.6839928277328658,"sequence":0.11752657470392035,"static":0.5983071006205644,"topology":0.0031425546130316993},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.204909853538848,"ms":2.056149842172604,"sequence":0.5838126163184877,"static":2.051344257261655,"topology":0.006578300169048262},"total_normalized_loss":0.3890874658779582,"weighted_normalized_losses":{"md":0.36832597276370016,"ms":1.3679856554657317,"sequence":0.058763287351960174,"static":0.1495767751551411,"topology":0.0007856386532579248}},"epoch":51,"improved":false,"step_identity_chain_sha256":"b06726e9afd1de13fd3dd5397fbb33c4e12079a6970199b902832d816ac333e4"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1850617024274701,"ms":0.6803602939273509,"sequence":0.11883763390680872,"static":0.5924614841583618,"topology":0.00247797867838134},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2059098143719069,"ms":2.045230087596152,"sequence":0.5903252957300588,"static":2.031302088703976,"topology":0.005187145353432089},"total_normalized_loss":0.3877995350744464,"weighted_normalized_losses":{"md":0.3701234048549402,"ms":1.3607205878547017,"sequence":0.05941881695340436,"static":0.14811537103959044,"topology":0.000619494669595335}},"epoch":52,"improved":false,"step_identity_chain_sha256":"11ed01719e06709d88c69773df2523b945afc2b94b4b270694cb70b2c15ac0ea"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18370845765909932,"ms":0.6804429154197278,"sequence":0.11740630981809595,"static":0.6040176960551386,"topology":0.003298208957414267},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2044041199175711,"ms":2.0454784559439227,"sequence":0.583215201156672,"static":2.070923495311994,"topology":0.006904130942432061},"total_normalized_loss":0.3877669754639681,"weighted_normalized_losses":{"md":0.36741691531819864,"ms":1.3608858308394556,"sequence":0.058703154909047976,"static":0.15100442401378464,"topology":0.0008245522393535668}},"epoch":53,"improved":false,"step_identity_chain_sha256":"913413f22ca2cd32737d80a3497310d56ee9a3c56c63f4e07cc369a0df62f64b"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18539548567909112,"ms":0.6766529714521453,"sequence":0.11625312833833575,"static":0.6043026706381643,"topology":0.0029920733819102396},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20628119995023134,"ms":2.0340855109087865,"sequence":0.577486778470272,"static":2.071900553705166,"topology":0.006263298258176171},"total_normalized_loss":0.3868094328873319,"weighted_normalized_losses":{"md":0.37079097135818223,"ms":1.3533059429042906,"sequence":0.05812656416916787,"static":0.15107566765954109,"topology":0.0007480183454775599}},"epoch":54,"improved":true,"step_identity_chain_sha256":"5a56dd1131a7e16092e6a90761dcddda7d953a9b02013be21bcdbbf0a802bc40"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18360077804570496,"ms":0.6775535407567341,"sequence":0.1180505303007513,"static":0.6068469521069519,"topology":0.0033234063843095},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20428430966555874,"ms":2.036792710982263,"sequence":0.5864153628767977,"static":2.080623828382069,"topology":0.006956876640762052},"total_normalized_loss":0.3867752984756138,"weighted_normalized_losses":{"md":0.3672015560914099,"ms":1.3551070815134683,"sequence":0.05902526515037565,"static":0.15171173802673799,"topology":0.000830851596077375}},"epoch":55,"improved":true,"step_identity_chain_sha256":"ddb2a2911f734055a9a27af2aac9ecee0676628234a6cc6d2a40783cdd07dada"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18322473303664413,"ms":0.6806532835732804,"sequence":0.11936803171721157,"static":0.6086277957821803,"topology":0.003679147716284187},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20386590133473975,"ms":2.046110843343596,"sequence":0.5929600439490125,"static":2.0867295948730087,"topology":0.007701548906619323},"total_normalized_loss":0.38810335699061416,"weighted_normalized_losses":{"md":0.36644946607328827,"ms":1.3613065671465607,"sequence":0.059684015858605784,"static":0.15215694894554507,"topology":0.0009197869290710468}},"epoch":56,"improved":false,"step_identity_chain_sha256":"35bcd33f3111f1bd29fab1d6ce26847179e59086d510cfd3201a811beb361e21"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18489347082031377,"ms":0.6799477774086968,"sequence":0.12097173139885309,"static":0.6050795141984117,"topology":0.0026783415226312546},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20572263064590274,"ms":2.0439900222908833,"sequence":0.6009264133364207,"static":2.0745640246458437,"topology":0.0056065642958219725},"total_normalized_loss":0.3884215652175417,"weighted_normalized_losses":{"md":0.36978694164062753,"ms":1.3598955548173937,"sequence":0.060485865699426544,"static":0.15126987854960292,"topology":0.0006695853806578136}},"epoch":57,"improved":false,"step_identity_chain_sha256":"0ce3e2612758e7a54a43bd3bb38b91b6b28f56240369c17e10387d65a57fb47f"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18345770502032352,"ms":0.6742300866444119,"sequence":0.11983664951638005,"static":0.6109896249676888,"topology":0.002424522954548807},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20412511875943667,"ms":2.0268020804208735,"sequence":0.5952879003004393,"static":2.094827317148577,"topology":0.005075246646671062},"total_normalized_loss":0.38572948901364407,"weighted_normalized_losses":{"md":0.36691541004064704,"ms":1.3484601732888237,"sequence":0.05991832475819003,"static":0.1527474062419222,"topology":0.0006061307386372017}},"epoch":58,"improved":true,"step_identity_chain_sha256":"bbc4d6ab68e210958fb43e54319fbc9ff2c3adf5fd559e6c903a7bebb9174ffb"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18430541764756114,"ms":0.6772358458843342,"sequence":0.11843834313645311,"static":0.6130100008762871,"topology":0.0025234864641710594},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20506833038791303,"ms":2.035837688889547,"sequence":0.5883418210146559,"static":2.1017543392636653,"topology":0.005282406665268042},"total_normalized_loss":0.38723701409342637,"weighted_normalized_losses":{"md":0.3686108352951223,"ms":1.3544716917686683,"sequence":0.05921917156822656,"static":0.15325250021907177,"topology":0.0006308716160427648}},"epoch":59,"improved":false,"step_identity_chain_sha256":"687971b0d82869252fa7c1b48eef634e327372223f0fb19ca240703d9752ed95"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1838877833078002,"ms":0.6749785765260923,"sequence":0.1211451243655598,"static":0.6121063319860106,"topology":0.0031933095673136393},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20460364748352222,"ms":2.0290521147628797,"sequence":0.6017877419491136,"static":2.0986560374273475,"topology":0.006684545362989639},"total_normalized_loss":0.3864260384477792,"weighted_normalized_losses":{"md":0.3677755666156004,"ms":1.3499571530521846,"sequence":0.0605725621827799,"static":0.15302658299650265,"topology":0.0007983273918284098}},"epoch":60,"improved":false,"step_identity_chain_sha256":"59e42a6d27800dbabab6785e733bdbebd6ef23959a5e0b1308c3cd3ded043300"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18457687056416733,"ms":0.6799754532590466,"sequence":0.12034037085904453,"static":0.6192550061116541,"topology":0.002440056515538208},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2053703638120949,"ms":2.044073218624268,"sequence":0.5977901333119712,"static":2.123165844513815,"topology":0.005107763003414316},"total_normalized_loss":0.3889397197465497,"weighted_normalized_losses":{"md":0.36915374112833466,"ms":1.3599509065180932,"sequence":0.060170185429522266,"static":0.15481375152791352,"topology":0.000610014128884552}},"epoch":61,"improved":false,"step_identity_chain_sha256":"dc2034f12c0777e9868357640285ed0f944cd341aed61e684219241eca93718e"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18451724904843766,"ms":0.6783744721375862,"sequence":0.11993402709049762,"static":0.610575358743474,"topology":0.002646263407398155},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20530402563906702,"ms":2.0392605116093083,"sequence":0.5957716228666721,"static":2.0934069719125956,"topology":0.005539415273181098},"total_normalized_loss":0.3878111722910029,"weighted_normalized_losses":{"md":0.36903449809687533,"ms":1.3567489442751723,"sequence":0.05996701354524881,"static":0.1526438396858685,"topology":0.0006615658518495387}},"epoch":62,"improved":false,"step_identity_chain_sha256":"914a329af955c22b510a20e9a742b47286eed9943d40890667c9b2cd01fd1b44"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.183479316404788,"ms":0.6776447250870751,"sequence":0.11841026921407123,"static":0.6209331289968829,"topology":0.002429041752571319},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20414916477276648,"ms":2.0370668200647524,"sequence":0.5882023639589442,"static":2.128919424473042,"topology":0.005084705833051504},"total_normalized_loss":0.3874587520556251,"weighted_normalized_losses":{"md":0.366958632809576,"ms":1.3552894501741501,"sequence":0.059205134607035616,"static":0.15523328224922073,"topology":0.0006072604381428297}},"epoch":63,"improved":false,"step_identity_chain_sha256":"c73bf6800b9b71249ca8b0567c1bb5a08f63b9a73e146bc7580374ac7f30834d"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1839770862407608,"ms":0.6767613667208217,"sequence":0.11981215230251706,"static":0.6118474175612922,"topology":0.0023987463457327595},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20470301083157091,"ms":2.034411357767912,"sequence":0.5951662105247107,"static":2.097768328393446,"topology":0.005021288548559121},"total_normalized_loss":0.38698890461023594,"weighted_normalized_losses":{"md":0.3679541724815216,"ms":1.3535227334416433,"sequence":0.05990607615125853,"static":0.15296185439032306,"topology":0.0005996865864331899}},"epoch":64,"improved":false,"step_identity_chain_sha256":"44177bb1bdc9d989f02c516b19401fd98bc6e0d74c6ee38ef91634c4447710b3"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1840057954520985,"ms":0.6791053649388362,"sequence":0.12021965637908434,"static":0.6151097989587911,"topology":0.0026189933671735247},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20473495427691787,"ms":2.04145764739349,"sequence":0.5971904847937477,"static":2.1089536667218987,"topology":0.005482330979569865},"total_normalized_loss":0.3881528694105806,"weighted_normalized_losses":{"md":0.368011590904197,"ms":1.3582107298776724,"sequence":0.06010982818954217,"static":0.15377744973969779,"topology":0.0006547483417933812}},"epoch":65,"improved":false,"step_identity_chain_sha256":"d1e4eae03c524e388b26674ded529f15d0ba620a9572a09d488b7fd91d1b337a"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18458304129881448,"ms":0.6778930106022428,"sequence":0.11855682889465703,"static":0.6244757621811947,"topology":0.0024463066961293023},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20537722971038216,"ms":2.037813190789893,"sequence":0.5889303983697586,"static":2.1410656287060936,"topology":0.005120846487745337},"total_normalized_loss":0.3881922070937548,"weighted_normalized_losses":{"md":0.36916608259762895,"ms":1.3557860212044857,"sequence":0.059278414447328516,"static":0.15611894054529868,"topology":0.0006115766740323256}},"epoch":66,"improved":false,"step_identity_chain_sha256":"35f9a9a13062d8eb7dc8563c986c972e4adc7fa99339ff87265f2a48c0de3dbf"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18442390757562716,"ms":0.6800514643494341,"sequence":0.1214192548395407,"static":0.6306108756564948,"topology":0.0031009598053264383},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20520016878977027,"ms":2.044301715452256,"sequence":0.6031494835775972,"static":2.162100361174005,"topology":0.006491229882529015},"total_normalized_loss":0.38961766602706965,"weighted_normalized_losses":{"md":0.3688478151512543,"ms":1.3601029286988682,"sequence":0.06070962741977035,"static":0.1576527189141237,"topology":0.0007752399513316096}},"epoch":67,"improved":false,"step_identity_chain_sha256":"b0f4cd477a45ba36039ed25cd16fc13b90ed5365e1c8ee898084bad7d13ffeca"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18361496530402258,"ms":0.6741262142646623,"sequence":0.12185378527980724,"static":0.6222918734381624,"topology":0.0024981878603235986},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20430009518837794,"ms":2.0264898298115566,"sequence":0.6053080111603258,"static":2.1335779896209632,"topology":0.00522944917352667},"total_normalized_loss":0.38652135342037897,"weighted_normalized_losses":{"md":0.36722993060804515,"ms":1.3482524285293247,"sequence":0.06092689263990362,"static":0.1555729683595406,"topology":0.0006245469650808997}},"epoch":68,"improved":false,"step_identity_chain_sha256":"076ecb1a4f813b50f84d86e9de78407809f775bab6232fff8c4bfbc37eaae592"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18410910225290328,"ms":0.673996083267659,"sequence":0.11852014571671958,"static":0.621748625770358,"topology":0.002154287613960629},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20484989909747253,"ms":2.0260986432111983,"sequence":0.588748174884215,"static":2.131715421079715,"topology":0.0045095638167523015},"total_normalized_loss":0.3862892344491128,"weighted_normalized_losses":{"md":0.36821820450580656,"ms":1.347992166535318,"sequence":0.05926007285835979,"static":0.1554371564425895,"topology":0.0005385719034901572}},"epoch":69,"improved":false,"step_identity_chain_sha256":"bd1b69f073ada6c240df716653e793aa4cdd588fbac71c752c182c77a9fb5607"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18340061655024986,"ms":0.6747456800720724,"sequence":0.12225088358616547,"static":0.6182707426786871,"topology":0.0027239572689114313},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2040615989921296,"ms":2.0283520050720183,"sequence":0.6072805948228267,"static":2.1197912177732077,"topology":0.005702051601029585},"total_normalized_loss":0.3865333420049254,"weighted_normalized_losses":{"md":0.3668012331004997,"ms":1.3494913601441447,"sequence":0.061125441793082734,"static":0.15456768566967177,"topology":0.0006809893172278578}},"epoch":70,"improved":false,"step_identity_chain_sha256":"58b877487b7272d4cb96cca3210d8253569729e85bfecd05b4bf15a815cd074f"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.18375603488669295,"ms":0.675921536063296,"sequence":0.12494299095684128,"static":0.6285623639921295,"topology":0.0021978501680299835},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.2044570569541034,"ms":2.031886744052814,"sequence":0.6206536234458765,"static":2.1550768733459806,"topology":0.004600753180848078},"total_normalized_loss":0.38790333818368766,"weighted_normalized_losses":{"md":0.3675120697733859,"ms":1.351843072126592,"sequence":0.06247149547842064,"static":0.15714059099803238,"topology":0.0005494625420074959}},"epoch":71,"improved":false,"step_identity_chain_sha256":"21fe679e356c863708cd463cb4f97cc5727ed675d96196e10849f99070f5a87d"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1837435376703293,"ms":0.675566786829554,"sequence":0.12207702804374553,"static":0.6313521664754512,"topology":0.002319502583325566},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20444315186478537,"ms":2.0308203328984935,"sequence":0.6064169683678112,"static":2.164641936667343,"topology":0.004855407817806645},"total_normalized_loss":0.3876154160572667,"weighted_normalized_losses":{"md":0.3674870753406586,"ms":1.351133573659108,"sequence":0.06103851402187276,"static":0.1578380416188628,"topology":0.0005798756458313915}},"epoch":72,"improved":false,"step_identity_chain_sha256":"fa7add9defcff3fd01d8bbfc74a36de8ad26fc8ce4d61890a7025e31dd55a327"},{"development":{"native_contract_sha256":"1f18091e8b5cd24c2d4937233064ccfb1522d61f71b0e6a2b4cca0cf7224b025","native_surface_sha256":"c102fca3c4dd0df8ac57172da75b90f1dff0954f526330f545474d47a0059f4a","normalized_losses":{"md":0.1842874184263841,"ms":0.6726172266165018,"sequence":0.1200924884666931,"static":0.6200451426897949,"topology":0.0026573603891926574},"parent_counts":{"md":5066,"ms":580,"sequence":55440,"static":5390,"topology":17650},"r4_provenance_chain_sha256":"377a4ff4acb5c062f86cf190f5598d63d99d10ee85b3640c812817976f4b483b","raw_parent_means":{"md":0.20504830346584982,"ms":2.021953664242555,"sequence":0.5965587788852591,"static":2.1258748916408514,"topology":0.0055626445519697575},"total_normalized_loss":0.385906232017773,"weighted_normalized_losses":{"md":0.3685748368527682,"ms":1.3452344532330036,"sequence":0.06004624423334655,"static":0.15501128567244873,"topology":0.0006643400972981643}},"epoch":73,"improved":false,"step_identity_chain_sha256":"e33e5b3a8e3b44c0f5af6f0ff0ac49320eaadbe28d8254685dc22687a8f0e0df"}],"receipt_sha256":"b595e1691e185649a671284778eeb81e0a37414ce5be7f20ac27d7e9c71cdecc","run_identity":{"attribution_claim":"fixed_sequence_heavy_loss_sensitivity_on_final_md_inclusive_a1111","base_control_cell_id":"A111","base_launch_config_sha256":"2a89d6b54668d4db8f1b9fe857f744d31116eb6d28b2695b31461161c1aea2b9","coefficients":{"md":2.0,"ms":2.0,"sequence":0.5,"static":0.25,"topology":0.25},"completed_epoch_resume":true,"core_source_sha256":"3e96d8092239c2c21f217ad5bae4ee7e07dbe0f7630b213bad468d6b08d3b1c1","evaluation_populations":["all_parent_primary","md_present_secondary"],"heldout_access":false,"hpo":false,"initial_model_state_sha256":"128cefb8648ca4519365ec48c3c8c1525735ef2325faf881b64366bae4c5c7bc","loss_denominator":5,"loss_policy":"WA3_FINAL_MS_MD_HEAVY","manifest_sha256":"eeebc9c7e2cfc701f3ad47e62696ae2247c8caec93d8b034d5f573b701eab2a1","maximum_epochs":100,"md_cell_id":"A1111","md_native_intersection_rosters":{"pretraining_development":{"count":5066,"sha256":"b94e6907dc441597ee7ea098894de9ffd7cfe71a61b9ae3a0489f5e1b73e79d8"},"pretraining_train":{"count":22872,"sha256":"6efa5bd7ff81f9b49aab026d44d613765041dc5ea10e116059c9477650f7403a"}},"md_null_receipt_sha256":"ee6147fb6f3448b27823d0edc4ac2922b5322af7967027b778d0b2da03e92aa6","md_package_summary_sha256":"39c6691d762b1ac2d0bed3464b1ed31e4fbe72b18e218ba4a553f3f94702a9e2","md_training_window_policy":{"fixed_development_seed":0,"pretraining_seed":42,"schema":"bertose_review_md_temporal_20x6_a1111_seeded_md_window_20260811_r1","seed43_legacy_exact":true},"native_adapter_contract":{"affinose_supported":false,"authority_set_sha256":"7804332dfc2be432b45f6a82459f21f0b577fc5c358f16b1fea90ba4cb6bb52f","cells":["A000","A100","A010","A001","A110","A101","A011","A111"],"common_seed":42,"development_manifest_sha256":"4eea50c1bd4eee0ea10062c287f31c619cef5835e2e660facd098698859f7e70","development_parent_count":55440,"development_roster_sha256":"dbadd12a88e29cc1a7ca1da85895d89f0162fa8bc9f3dcf8aebf5b8781a1e698","disabled_branch_contract":"static-disabled cell opens no static package/loader/mask stream/payload","downstream_supported":false,"execution_certified":false,"gpu_launch_authorized":false,"loss_policy":{"adaptive_or_weight_ablation":false,"coefficients":[1,"topology_bit","ms_bit","static_bit"],"denominator":4},"matched_weight_policies":["WA1_FINAL_MD_EQUAL_NORMALIZED","WA2_FINAL_MD_SEQUENCE_HEAVY"],"md_supported":false,"nova_submission_authorized":false,"postfit_static":{"binding_sha256":"4ac795da03db66b1f08ad03839dd4b2432fa6f794e6afe77575ae59127f2289b","compatibility_view_persisted":false,"direct_postfit_producer_source_sha256":"8e57c17fd43f3894f94f980cf70a0d6d7f183cf04c26780c3fe30c1932bb7abb","direct_publication_validated_before_compatibility_view":true,"direct_static_bridge_evidence":{"bridge_evidence_sha256":"908452818740e3a406fca7b20605343679c791ed58162b07453635f4ed85e1dd","compatibility_view_persisted":false,"direct_export_receipt_sha256":"b68da847cd4ccd5b6cbfd65e42a4d4b504fcfae00136851fdc980acb1690ad72","direct_join_receipt_sha256":"7b55cf83bd3175e9a9e0be15fc2a9fc998d0803bc67cb2761f69f612e9b6c921","direct_null_file_sha256":"661d04d76fcf36d116feb117154eac01e6569e377d4245c07653b28696e1227b","direct_null_receipt_sha256":"84d8fdb5e960ed0f695c1618d881fe9dd13062e2ad143e099fc7db6415e54c89","direct_publication_file_sha256":"77ba176a9fab70e75b3c2c423c857d1e266f2021875aea01e15bac3f11f327d1","direct_publication_receipt_sha256":"654faac335def8eccb7c50eb8a7d871036bf2a8c223e61f0cb11027830869a84","direct_token_file_sha256":"f9a032f0bd3ad47b99c8a3df2fc46596500e13baf0e77f4b39d26a8351dc7323","direct_token_package_semantic_sha256":"b4c0adb42cc2444e91611c4492c8d385c10fe706a862dbe9b51c144aad80f9e7","native_ablation_data_binding_authorized_by_source_publication":false,"nova_submission_authorized_by_source_publication":false,"official_submitted_artifacts_modified":false,"owner_amendment_file_sha256":"876a3746653254a812d5607d1115abfa112fcefb0772b3828efcb26865dfaf7d","owner_amendment_receipt_sha256":"672d247a416280617634b8f51c7c69716fd7a6fe010db4109fe634b25c531b93","schema":"bertose_review_a5_native_eight_direct_static_bridge_20260724_r1","writer_source_sha256":"ceffd07edb6b8b322baecd95e023053ad8c783cc97cdb2edfc03c0b4fdeeaab6"},"direct_static_bridge_source_sha256":"c71ba654568a24993bc1733b26b6863b11e5c198c53871a6183b485ab96540f0","masker_binding_sha256":"c3373ddbe58ebe15cf6e941f48ea71bcb569fe14b94f394090ffbdaf12faad36","max_static_tokens":192,"nova_submission_authorized":false,"null_receipt_sha256":"661d04d76fcf36d116feb117154eac01e6569e377d4245c07653b28696e1227b","null_scale":3.4285808327094895,"null_scale_hex":"0x1.b6dbbc9a17009p+1","parent_counts":{"pretraining_development":5390,"pretraining_train":22980},"predecessor_compatibility_binding_sha256":"3105b52ff97f720a02be38fb24433087eddd19b4da362fc601a8e7540bb29d25","publication_receipt_semantic_sha256":"a79630e44bba95c7bec3bc59235dc4d8f5012968049e591bd127a26c52063803","publication_receipt_sha256":"77ba176a9fab70e75b3c2c423c857d1e266f2021875aea01e15bac3f11f327d1","release_receipt_sha256":"261099ec7bf32cd72e261ea95d0631702b46cb53cc19085827ed368ba3e3bb63","residue_counts":{"pretraining_development":51237,"pretraining_train":205801},"schema":"bertose_review_a5_native_eight_direct_static_runtime_binding_20260724_r8","state_counts":{"pretraining_development":7964,"pretraining_train":34408},"support_binding_sha256":"38c47a7c323b29bfe9c6a76668de45370789687e50663b0acf52b25bc5f96779","support_sha256_by_slot":["427c4b27091096e0260bb3ad896db841b4b41e9c615bec24cc4330e3e4ddf158","fc55a9e195344141ed497f5a59fa8ab8fcd58f04ccb21c6b7f5a9166cb8d19b6","da96778691370fa5a1c59e471af23113f72c1a93bc277f40d8ea05bdf4aa4720","db2889304eef19132309f70744dc696d2b1bb344473296b5fd7fae48afca8f5c"],"token_count":1028152,"token_export_receipt_sha256":"0e851404deed73e8557ea385a18f9d340c333f259d6c5d171fedc49b09959699","token_null_receipt_sha256":"6333289557fb1fc23324351f30b546a493ef1f2e6ea71efde49a812d3d38bb54","token_package_semantic_sha256":"f434b2cb0ecea84053563faeed700ffd351658e3bb79c8daa4b833404d6691be","token_package_sha256":"f9a032f0bd3ad47b99c8a3df2fc46596500e13baf0e77f4b39d26a8351dc7323","training_authorized":false},"predecessor_adapter_r2_receipt_sha256":"3b2118e128a5550ba4918b4f4f2c6d8045e319b7cff37b76d74dce6b3220c9f0","predecessor_adapter_r2_source_sha256":"9f8f167148aa234df413e4c3d4e1846881781c8e5a19bd91b0b178b260a3a537","predecessor_common_seed":43,"processing_contract":{"ms":"frozen MS-V3 train selection and mask streams parameterized by the declared upstream seed; fixed development seed 0","sequence":"frozen R4 train stream parameterized by the declared upstream seed; fixed development seed 0","static":"frozen final static token stream parameterized by the declared upstream seed; fixed development seed 0","topology":"R4-bound original-residue BFS matrix with receipt-bound inverse-multiplicity equal-parent loss"},"receipt_sha256":"77ba176a9fab70e75b3c2c423c857d1e266f2021875aea01e15bac3f11f327d1","schema":"bertose_review_md_temporal_20x6_a1111_wa2_seed_adapter_20260811_r1","scientific_launch_authorized":false,"seed_parameterization":{"fixed_development_seed":0,"model_rng_seed":42,"ms_train_selection_and_mask_seed":42,"r5_epoch_plan_seed":42,"sequence_train_mask_seed":42,"static_train_mask_seed":42},"sequence_topology_r4":{"bfs_replay_receipt_sha256":"f20a1dd444f2760ccd8605d53ad716ceb55112fd32d3409826bcaf78ff2c6c3d","predecessor_receipt_sha256":"53b058a2032c424718a96757b3aa63df5160c20910001fcb128b0ace03a13a4c","predecessor_relative_path":"review/multimodal/outputs/review_a5_official_ragged_sequence_topology_runtime_20260721_r3","provenance_fields":["sequence_rows","roles","seq_token_categories","topology_rows","topology_residue_counts","topology_target_counts"],"r4_masker_only_checkpoint_restore":true,"r4_store_collation_required":true,"rows_only_through_r4_store_sample":true,"runtime_receipt_sha256":"654f5b9728c3dfd2588c4b570b0e3a1bcab8feb366af28eeead36f9beb37d921","runtime_sha256":"efc56a84cb82f30c0566da83a38bf0f02fdd507e02d116d827c1bbd827151ecf","store_manifest_identity_sha256":"7bd44c2f15715924bce78c7bbdbe57d40fc69aaf90ed834e17d9632bded0fc17","topology_loss_source_sha256":"64eaf9174f523ae909c84987049d071bf3869ca8e83919f14f0572ef77b0530e"},"source_sha256":"4430560565a18da0e68700d60526d3dec15fabd79854111d1e85deb59e2381c8","static_final_token_package_bound":true,"status":"WA2_SEED_PARAMETERIZED_SUCCESSOR","successor_source_sha256":"dd74253863f39150af4ddc7e8d48c0a366e1f327c30aa50e0748078330b97b85","train_manifest_sha256":"13b7ebc78b22baa1a38d2ae40da202dcc1e20e56f44220b4d4d5003ca5f3b8f2","train_parent_count":221827,"train_roster_sha256":"2a7c8121c9ec88418e930cdec47302b7ef2b4d92e01fafa523218461a249de6e","training_authorized":false,"weight_ablation_supported":false,"world_size":1},"native_adapter_contract_sha256":"ad9d49ba49f69d17e8f462930179af4832f741edf6447b880944eef0988423bd","native_launch_sha256":"30082379d47318f5d9e17fafad4aa018e7e9f0f0bf1aac559178d46784fe4b9f","optimizer_contract_sha256":"4c4498fd71ea6a14e654ee7a1e6737bcd578ee328ec73de731cf8da12396c6c0","owner_decision_sha256":"2c7fdb2f522b52fd0692fac9fce8ef5b0a202d1b418b1b9f3570ad7ea9944b83","parameter_summary":{"four_slot_fusion_parameters":2952192,"md_branch_parameters":179206,"total_parameters":138487995,"trainable_parameters":138487995},"patience":15,"precision":"fp32_no_amp","pretraining_seed":42,"runner_source_sha256":"dd74253863f39150af4ddc7e8d48c0a366e1f327c30aa50e0748078330b97b85","schema":"bertose_review_md_temporal_20x6_a1111_wa2_training_20260811_r1","selection_rule":"strict_lower_earliest_tie","semantic_array_id":"md20x6-a1111-wa345-20260817-r1","static_binding_sha256":"4ac795da03db66b1f08ad03839dd4b2432fa6f794e6afe77575ae59127f2289b"},"run_identity_sha256":"55dd7ff33d2196cb1da5e215adb79b0880249f8f1e8c541a7fe36f5759c369d5","schema":"bertose_review_md_temporal_20x6_a1111_wa2_final_20260811_r1","selection":{"best_epoch":58,"best_loss":0.38572948901364407,"completed_epochs":73,"epochs_without_improvement":15,"stop_reason":"patience_exhausted"},"status":"PASS_TRAINING_COMPLETE","terminal_attempt_identity":{"actual_slurm_route":{"account":"ratul-scavenger","partition":"scavenger","qos":"scavenger"},"attempt_sha256":"f299e47d3aaf076a1fc97d2c6ff03e62c0f913bb5ccd97098476e2f02aa302f4","device":{"compute_capability":[9,0],"cuda_visible_devices":"0","name":"NVIDIA H200 NVL","total_memory_bytes":150109880320},"slurm_array_job_id":"12042738","slurm_array_task_id":"0","slurm_job_id":"12042740","slurm_restart_count":1}}

releases/2026-10-02/provenance/affinose_arms_on_test_20260909.json

@@ -0,0 +1,263 @@
+{
+ "bob_B_protein_s43": {
+  "stratum": "test_protein_cold",
+  "seed": 43,
+  "test_macro": 0.24463542038572242,
+  "test_pooled": 0.26184445034413995,
+  "assays": 246,
+  "rows": 38539,
+  "dir": "affinose_bob_20260909_bob_B_protein_s43"
+ },
+ "bob_B_protein_s44": {
+  "stratum": "test_protein_cold",
+  "seed": 44,
+  "test_macro": 0.24516174432219207,
+  "test_pooled": 0.2730962401378244,
+  "assays": 246,
+  "rows": 38539,
+  "dir": "affinose_bob_20260909_bob_B_protein_s44"
+ },
+ "mo_A_glycan_s42": {
+  "stratum": "test_glycan_cold",
+  "seed": 42,
+  "test_macro": 0.33405850648525903,
+  "test_pooled": 0.3519114017717813,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_mo_20260908_mo_A_glycan_s42"
+ },
+ "mo_C_doubly_s42": {
+  "stratum": "test_doubly_cold",
+  "seed": 42,
+  "test_macro": 0.17732109020146009,
+  "test_pooled": 0.19643520103251555,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_mo_20260908_mo_C_doubly_s42"
+ },
+ "mof_B_protein_s43": {
+  "stratum": "test_protein_cold",
+  "seed": 43,
+  "test_macro": 0.24512556467979302,
+  "test_pooled": 0.2699137753848991,
+  "assays": 246,
+  "rows": 38539,
+  "dir": "affinose_mof_20260909_mof_B_protein_s43"
+ },
+ "mof_B_protein_s44": {
+  "stratum": "test_protein_cold",
+  "seed": 44,
+  "test_macro": 0.24489399647831056,
+  "test_pooled": 0.2547891998912819,
+  "assays": 246,
+  "rows": 38539,
+  "dir": "affinose_mof_20260909_mof_B_protein_s44"
+ },
+ "mof_C_doubly_s43": {
+  "stratum": "test_doubly_cold",
+  "seed": 43,
+  "test_macro": 0.1839765095395252,
+  "test_pooled": 0.2208411762069753,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_mof_20260909_mof_C_doubly_s43"
+ },
+ "mof_C_doubly_s44": {
+  "stratum": "test_doubly_cold",
+  "seed": 44,
+  "test_macro": 0.17430173158048537,
+  "test_pooled": 0.19176702047106786,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_mof_20260909_mof_C_doubly_s44"
+ },
+ "bo_A_glycan_s42": {
+  "stratum": "test_glycan_cold",
+  "seed": 42,
+  "test_macro": 0.2882683038203673,
+  "test_pooled": 0.3136364354792883,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_sa_20260908_bo_A_glycan_s42"
+ },
+ "bo_B_protein_s42": {
+  "stratum": "test_protein_cold",
+  "seed": 42,
+  "test_macro": 0.2522396003161021,
+  "test_pooled": 0.2653369332383739,
+  "assays": 246,
+  "rows": 38539,
+  "dir": "affinose_sa_20260908_bo_B_protein_s42"
+ },
+ "bo_C_doubly_s42": {
+  "stratum": "test_doubly_cold",
+  "seed": 42,
+  "test_macro": 0.16472937852334543,
+  "test_pooled": 0.1926274802936194,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_sa_20260908_bo_C_doubly_s42"
+ },
+ "boa_A_glycan_s43": {
+  "stratum": "test_glycan_cold",
+  "seed": 43,
+  "test_macro": 0.3374435261201508,
+  "test_pooled": 0.36037024272127394,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_sa_20260908_boa_A_glycan_s43"
+ },
+ "boa_A_glycan_s44": {
+  "stratum": "test_glycan_cold",
+  "seed": 44,
+  "test_macro": 0.30969468493798785,
+  "test_pooled": 0.32123919236737947,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_sa_20260908_boa_A_glycan_s44"
+ },
+ "boc_C_doubly_s43": {
+  "stratum": "test_doubly_cold",
+  "seed": 43,
+  "test_macro": 0.16514492967071465,
+  "test_pooled": 0.1791689218089693,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_sa_20260908_boc_C_doubly_s43"
+ },
+ "boc_C_doubly_s44": {
+  "stratum": "test_doubly_cold",
+  "seed": 44,
+  "test_macro": 0.20300180090714,
+  "test_pooled": 0.23511093681840797,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_sa_20260908_boc_C_doubly_s44"
+ },
+ "mc_A_glycan_s42": {
+  "stratum": "test_glycan_cold",
+  "seed": 42,
+  "test_macro": 0.27841973422388244,
+  "test_pooled": 0.3022162276393939,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_sa_20260908_mc_A_glycan_s42"
+ },
+ "mc_B_protein_s42": {
+  "stratum": "test_protein_cold",
+  "seed": 42,
+  "test_macro": 0.25218496294299203,
+  "test_pooled": 0.26171877856861664,
+  "assays": 246,
+  "rows": 38539,
+  "dir": "affinose_sa_20260908_mc_B_protein_s42"
+ },
+ "mc_C_doubly_s42": {
+  "stratum": "test_doubly_cold",
+  "seed": 42,
+  "test_macro": 0.15450571314627123,
+  "test_pooled": 0.1575716723657401,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_sa_20260908_mc_C_doubly_s42"
+ },
+ "mo_B_protein_s42": {
+  "stratum": "test_protein_cold",
+  "seed": 42,
+  "test_macro": 0.23260289913763402,
+  "test_pooled": 0.26884245311406896,
+  "assays": 246,
+  "rows": 38539,
+  "dir": "affinose_sa_20260908_mo_B_protein_s42"
+ },
+ "moc_A_glycan_s43": {
+  "stratum": "test_glycan_cold",
+  "seed": 43,
+  "test_macro": 0.318371586837939,
+  "test_pooled": 0.3491029922366602,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_sa_20260908_moc_A_glycan_s43"
+ },
+ "moc_A_glycan_s44": {
+  "stratum": "test_glycan_cold",
+  "seed": 44,
+  "test_macro": 0.3354799039624282,
+  "test_pooled": 0.3562564894744605,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_sa_20260908_moc_A_glycan_s44"
+ },
+ "sa_A_glycan_s42": {
+  "stratum": "test_glycan_cold",
+  "seed": 42,
+  "test_macro": 0.28116041536475034,
+  "test_pooled": 0.2995676811524887,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_sa_20260908_sa_A_glycan_s42"
+ },
+ "sa_C_doubly_s42": {
+  "stratum": "test_doubly_cold",
+  "seed": 42,
+  "test_macro": 0.14451918425842353,
+  "test_pooled": 0.16719428719500484,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_sa_20260908_sa_C_doubly_s42"
+ },
+ "swe_A_glycan_s42": {
+  "stratum": "test_glycan_cold",
+  "seed": 42,
+  "test_macro": 0.2919377626107431,
+  "test_pooled": 0.3060559058312503,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_swe_20260908_swe_A_glycan_s42"
+ },
+ "swe_C_doubly_s42": {
+  "stratum": "test_doubly_cold",
+  "seed": 42,
+  "test_macro": 0.12325096614703701,
+  "test_pooled": 0.13077810558700573,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_swe_20260908_swe_C_doubly_s42"
+ },
+ "sz2_A_glycan_s42": {
+  "stratum": "test_glycan_cold",
+  "seed": 42,
+  "test_macro": 0.28711041488202854,
+  "test_pooled": 0.3024540500744863,
+  "assays": 1767,
+  "rows": 37295,
+  "dir": "affinose_sz2_20260908_sz2_A_glycan_s42"
+ },
+ "sz2_C_doubly_s42": {
+  "stratum": "test_doubly_cold",
+  "seed": 42,
+  "test_macro": 0.1490739924202869,
+  "test_pooled": 0.166626209128426,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_sz2_20260908_sz2_C_doubly_s42"
+ },
+ "szc_C_doubly_s43": {
+  "stratum": "test_doubly_cold",
+  "seed": 43,
+  "test_macro": 0.13519544496948036,
+  "test_pooled": 0.1757217730192651,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_szc_20260908_szc_C_doubly_s43"
+ },
+ "szc_C_doubly_s44": {
+  "stratum": "test_doubly_cold",
+  "seed": 44,
+  "test_macro": 0.12914485639778248,
+  "test_pooled": 0.1359993175882641,
+  "assays": 212,
+  "rows": 3691,
+  "dir": "affinose_szc_20260908_szc_C_doubly_s44"
+ }
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mo_20260908_mo_A_glycan_s42/receipt.json

@@ -0,0 +1,101 @@
+{
+  "cell_id": "mo_A_glycan_s42",
+  "fingerprint": "cbcc86152b41f424bf9d201d53843e0fdeb2cd9f934e5a1d3f37fe369c35f874",
+  "manifest_sha256": "mo_20260908_moA_glycan",
+  "args": {
+    "csv_path": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_A_glycan_binding.csv",
+    "split_path": "/work/ratul1/supantha/Bertint/v2_artifacts/affinose_v2_splits_direct_edit_guarded.json",
+    "protein_emb_path": "/work/ratul1/supantha/Bertint/affinose_v2_esmc_by_seqhash_r2.h5",
+    "vocab_path": "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json",
+    "bertose_checkpoint": "/work/ratul1/supantha/bertose_a5_static_precache_20260723_r2c4_closure31_py310_3c8d5299a4af15bc/writing/review/multimodal/outputs/a5_wa345_pretraining_20260817_r1/production/review_md20x6_md20x6-a1111-wa345-20260817-r1_A1111_wa3_seed42/review_checkpoints/review_md20x6_checkpoint_best.pt",
+    "output_dir": "/work/ratul1/supantha/Bertint/checkpoints/affinose_mo_20260908_mo_A_glycan_s42",
+    "freeze_layers": 4,
+    "shared_dim": 512,
+    "num_cross_layers": 2,
+    "num_heads": 8,
+    "swe_slices": 512,
+    "dropout": 0.1,
+    "protein_dim": 960,
+    "separate_swe": false,
+    "lr_encoder": 1e-05,
+    "lr_head": 5e-05,
+    "weight_decay": 0.01,
+    "max_grad_norm": 1.0,
+    "batch_size": 32,
+    "epochs": 30,
+    "patience": 10,
+    "max_glycan_length": 256,
+    "max_protein_length": 1024,
+    "protein_mode": "real",
+    "ranking_loss": false,
+    "assays_per_batch": 4,
+    "rows_per_assay": 8,
+    "protein_binding_channel": false,
+    "glycan_only": false,
+    "protein_attentive_pool": false,
+    "motif_additive_dim": 165,
+    "glycan_size_channel": false,
+    "seed": 42,
+    "roles_tsv": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_A_glycan_roles.tsv.gz",
+    "train_stratum": "fit_train",
+    "val_stratum": "val_glycan_cold",
+    "test_stratum": "val_glycan_cold",
+    "features_dir": "/work/ratul1/supantha/Bertint/data/review_affinose_glycan_features_20260824_r1",
+    "expected_train_rows": 484491,
+    "expected_val_rows": 36745,
+    "expected_test_rows": 36745,
+    "manifest_sha256": "mo_20260908_moA_glycan",
+    "cell_id": "mo_A_glycan_s42",
+    "input_hashes": "/work/ratul1/supantha/Bertint/manifests/affinose_input_hashes_moA_glycan_20260908.json",
+    "warmup_pct": 0.05,
+    "target_col": "target_rank",
+    "checkpoint_interval": 1,
+    "resume": false,
+    "pooling_mode": "mean",
+    "interaction_mode": "concat",
+    "no_cross_attention": false
+  },
+  "input_hashes": {
+    "csv": "aa2c0104eb4ac96541081eaa2f0858a6b8575d2c83ce869822ee5107d12ddcb9",
+    "roles_tsv": "fd43b4aac814f670519120a012a8ef774a2d4c651bcdc3c34488ac7bed2a9a72",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "9256821b6057a857ec009868cda30c10d1133790ca283edf7b36bd04e0c784ad",
+      "val": "dba86d01797d9f2a30176028da2d07c3f784d8f013faf2ade70391081a20c846",
+      "test": "dba86d01797d9f2a30176028da2d07c3f784d8f013faf2ade70391081a20c846"
+    }
+  },
+  "roster_digests": {
+    "train": "9256821b6057a857ec009868cda30c10d1133790ca283edf7b36bd04e0c784ad",
+    "val": "dba86d01797d9f2a30176028da2d07c3f784d8f013faf2ade70391081a20c846",
+    "test": "dba86d01797d9f2a30176028da2d07c3f784d8f013faf2ade70391081a20c846"
+  },
+  "slurm_job_id": "12247963",
+  "slurm_array_task_id": "0",
+  "slurm_restart_count": null,
+  "node": "nova20-amp-1",
+  "gpu": "NVIDIA A100-PCIE-40GB"
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mo_20260908_mo_A_glycan_s42/results.json

@@ -0,0 +1,339 @@
+{
+  "task_type": "regression",
+  "architecture": "cross-attention=True pooling=mean interaction=concat + live Bertose",
+  "best_metric": 0.3518440936915808,
+  "best_metric_is": "validation",
+  "best_epoch": 8,
+  "early_stopped": true,
+  "epochs_ran": 19,
+  "test_metrics": {
+    "spearman": 0.40237059401182945,
+    "pearson": 0.4124835133552551,
+    "mse": 0.07252673804759979,
+    "macro_spearman": 0.3518440936915808,
+    "macro_assays_eligible": 1692,
+    "macro_assays_total": 1693
+  },
+  "test_loss": 0.07250597555225989,
+  "history": [
+    {
+      "epoch": 1,
+      "train_loss": 0.08178654776577449,
+      "val_loss": 0.07449441553264519,
+      "val_metrics": {
+        "spearman": 0.33265511442497175,
+        "pearson": 0.32712677121162415,
+        "mse": 0.07448939234018326,
+        "macro_spearman": 0.2746683991825071,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 7.600383347137149e-06,
+      "lr_head": 3.8001916735685747e-05
+    },
+    {
+      "epoch": 2,
+      "train_loss": 0.07405700735830484,
+      "val_loss": 0.07659707693066983,
+      "val_metrics": {
+        "spearman": 0.3720591600427688,
+        "pearson": 0.37388962507247925,
+        "mse": 0.07660496979951859,
+        "macro_spearman": 0.3207894429302261,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 9.992405607129421e-06,
+      "lr_head": 4.996202803564711e-05
+    },
+    {
+      "epoch": 3,
+      "train_loss": 0.06950348176932596,
+      "val_loss": 0.0758063778154766,
+      "val_metrics": {
+        "spearman": 0.3790002388657775,
+        "pearson": 0.38117125630378723,
+        "mse": 0.07581878453493118,
+        "macro_spearman": 0.32246448806993605,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 9.931800798174588e-06,
+      "lr_head": 4.965900399087294e-05
+    },
+    {
+      "epoch": 4,
+      "train_loss": 0.06677828642780369,
+      "val_loss": 0.07234074125103684,
+      "val_metrics": {
+        "spearman": 0.3830188559921474,
+        "pearson": 0.39124181866645813,
+        "mse": 0.07236022502183914,
+        "macro_spearman": 0.3261992361563057,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 9.811330851097227e-06,
+      "lr_head": 4.905665425548613e-05
+    },
+    {
+      "epoch": 5,
+      "train_loss": 0.06486930890547266,
+      "val_loss": 0.07428531616511191,
+      "val_metrics": {
+        "spearman": 0.4039017349602038,
+        "pearson": 0.40416157245635986,
+        "mse": 0.0743052139878273,
+        "macro_spearman": 0.34451370150779037,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 9.632458107861948e-06,
+      "lr_head": 4.816229053930974e-05
+    },
+    {
+      "epoch": 6,
+      "train_loss": 0.06333981823825936,
+      "val_loss": 0.07813900106264728,
+      "val_metrics": {
+        "spearman": 0.36745023533302545,
+        "pearson": 0.3778190016746521,
+        "mse": 0.07817018032073975,
+        "macro_spearman": 0.32126358975578523,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 9.397353841264184e-06,
+      "lr_head": 4.698676920632092e-05
+    },
+    {
+      "epoch": 7,
+      "train_loss": 0.06192197361992377,
+      "val_loss": 0.07327253127987744,
+      "val_metrics": {
+        "spearman": 0.40534431983142905,
+        "pearson": 0.4101991355419159,
+        "mse": 0.07328689843416214,
+        "macro_spearman": 0.3481927746525873,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 9.108871898619753e-06,
+      "lr_head": 4.554435949309877e-05
+    },
+    {
+      "epoch": 8,
+      "train_loss": 0.0606018938901666,
+      "val_loss": 0.07376345989818776,
+      "val_metrics": {
+        "spearman": 0.3837663608799417,
+        "pearson": 0.3917231857776642,
+        "mse": 0.07378335297107697,
+        "macro_spearman": 0.34328721248155164,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 8.770514059924366e-06,
+      "lr_head": 4.385257029962183e-05
+    },
+    {
+      "epoch": 9,
+      "train_loss": 0.05928352163667491,
+      "val_loss": 0.07250597555225989,
+      "val_metrics": {
+        "spearman": 0.40237059401182945,
+        "pearson": 0.4124835133552551,
+        "mse": 0.07252673804759979,
+        "macro_spearman": 0.3518440936915808,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 8.386387530988106e-06,
+      "lr_head": 4.193193765494053e-05
+    },
+    {
+      "epoch": 10,
+      "train_loss": 0.057978798184743385,
+      "val_loss": 0.07709632041475843,
+      "val_metrics": {
+        "spearman": 0.3843505992519891,
+        "pearson": 0.3893249034881592,
+        "mse": 0.07710817456245422,
+        "macro_spearman": 0.3388635804374225,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 7.961155087520675e-06,
+      "lr_head": 3.980577543760337e-05
+    },
+    {
+      "epoch": 11,
+      "train_loss": 0.05657076605068323,
+      "val_loss": 0.07423298842751067,
+      "val_metrics": {
+        "spearman": 0.3998620770684936,
+        "pearson": 0.4072037935256958,
+        "mse": 0.07424739003181458,
+        "macro_spearman": 0.34683370121850293,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 7.499978475350636e-06,
+      "lr_head": 3.7499892376753175e-05
+    },
+    {
+      "epoch": 12,
+      "train_loss": 0.05521496029820552,
+      "val_loss": 0.07893912996399703,
+      "val_metrics": {
+        "spearman": 0.39539492684739164,
+        "pearson": 0.40234139561653137,
+        "mse": 0.07895530760288239,
+        "macro_spearman": 0.34484224357882526,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 7.0084557538233345e-06,
+      "lr_head": 3.504227876911667e-05
+    },
+    {
+      "epoch": 13,
+      "train_loss": 0.05384385342549856,
+      "val_loss": 0.07758754271336282,
+      "val_metrics": {
+        "spearman": 0.379476937601036,
+        "pearson": 0.38807427883148193,
+        "mse": 0.07760068774223328,
+        "macro_spearman": 0.33086376694394215,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 6.492553342943792e-06,
+      "lr_head": 3.246276671471896e-05
+    },
+    {
+      "epoch": 14,
+      "train_loss": 0.05236243655586875,
+      "val_loss": 0.08031580967745955,
+      "val_metrics": {
+        "spearman": 0.3715908296671469,
+        "pearson": 0.383950412273407,
+        "mse": 0.08032692223787308,
+        "macro_spearman": 0.3383192853501629,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 5.958533599120159e-06,
+      "lr_head": 2.979266799560079e-05
+    },
+    {
+      "epoch": 15,
+      "train_loss": 0.050935477340176526,
+      "val_loss": 0.08091087176993787,
+      "val_metrics": {
+        "spearman": 0.3878922278405009,
+        "pearson": 0.39411112666130066,
+        "mse": 0.08091336488723755,
+        "macro_spearman": 0.33990795245997407,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 5.412878798640137e-06,
+      "lr_head": 2.7064393993200682e-05
+    },
+    {
+      "epoch": 16,
+      "train_loss": 0.049360674873292626,
+      "val_loss": 0.07987832513397107,
+      "val_metrics": {
+        "spearman": 0.38379380252351775,
+        "pearson": 0.38983529806137085,
+        "mse": 0.07989616692066193,
+        "macro_spearman": 0.3426433799929684,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 4.862212451617974e-06,
+      "lr_head": 2.4311062258089866e-05
+    },
+    {
+      "epoch": 17,
+      "train_loss": 0.04789994738429645,
+      "val_loss": 0.08231175134041135,
+      "val_metrics": {
+        "spearman": 0.3703845261663136,
+        "pearson": 0.37726807594299316,
+        "mse": 0.08232666552066803,
+        "macro_spearman": 0.32730402321783136,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 4.3132189015541166e-06,
+      "lr_head": 2.156609450777058e-05
+    },
+    {
+      "epoch": 18,
+      "train_loss": 0.046404292282118356,
+      "val_loss": 0.08147809532405346,
+      "val_metrics": {
+        "spearman": 0.3681362465685154,
+        "pearson": 0.37861087918281555,
+        "mse": 0.08149037510156631,
+        "macro_spearman": 0.32856892560631556,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 3.772562186459968e-06,
+      "lr_head": 1.886281093229984e-05
+    },
+    {
+      "epoch": 19,
+      "train_loss": 0.0449393058915869,
+      "val_loss": 0.08430918386843124,
+      "val_metrics": {
+        "spearman": 0.3660089664694847,
+        "pearson": 0.37466129660606384,
+        "mse": 0.08431710302829742,
+        "macro_spearman": 0.32766400341899166,
+        "macro_assays_eligible": 1692,
+        "macro_assays_total": 1693
+      },
+      "lr_encoder": 3.246805146463778e-06,
+      "lr_head": 1.6234025732318888e-05
+    }
+  ],
+  "fingerprint": "cbcc86152b41f424bf9d201d53843e0fdeb2cd9f934e5a1d3f37fe369c35f874",
+  "input_hashes": {
+    "csv": "aa2c0104eb4ac96541081eaa2f0858a6b8575d2c83ce869822ee5107d12ddcb9",
+    "roles_tsv": "fd43b4aac814f670519120a012a8ef774a2d4c651bcdc3c34488ac7bed2a9a72",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "9256821b6057a857ec009868cda30c10d1133790ca283edf7b36bd04e0c784ad",
+      "val": "dba86d01797d9f2a30176028da2d07c3f784d8f013faf2ade70391081a20c846",
+      "test": "dba86d01797d9f2a30176028da2d07c3f784d8f013faf2ade70391081a20c846"
+    }
+  }
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mo_20260908_mo_C_doubly_s42/receipt.json

@@ -0,0 +1,101 @@
+{
+  "cell_id": "mo_C_doubly_s42",
+  "fingerprint": "20f398ef9542391b9fa12a01e6db7ad58ced7587299a05dfd707be73ddbb9ec6",
+  "manifest_sha256": "mo_20260908_moC_doubly",
+  "args": {
+    "csv_path": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_C_doubly_binding.csv",
+    "split_path": "/work/ratul1/supantha/Bertint/v2_artifacts/affinose_v2_splits_direct_edit_guarded.json",
+    "protein_emb_path": "/work/ratul1/supantha/Bertint/affinose_v2_esmc_by_seqhash_r2.h5",
+    "vocab_path": "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json",
+    "bertose_checkpoint": "/work/ratul1/supantha/bertose_a5_static_precache_20260723_r2c4_closure31_py310_3c8d5299a4af15bc/writing/review/multimodal/outputs/a5_wa345_pretraining_20260817_r1/production/review_md20x6_md20x6-a1111-wa345-20260817-r1_A1111_wa3_seed42/review_checkpoints/review_md20x6_checkpoint_best.pt",
+    "output_dir": "/work/ratul1/supantha/Bertint/checkpoints/affinose_mo_20260908_mo_C_doubly_s42",
+    "freeze_layers": 4,
+    "shared_dim": 512,
+    "num_cross_layers": 2,
+    "num_heads": 8,
+    "swe_slices": 512,
+    "dropout": 0.1,
+    "protein_dim": 960,
+    "separate_swe": false,
+    "lr_encoder": 1e-05,
+    "lr_head": 5e-05,
+    "weight_decay": 0.01,
+    "max_grad_norm": 1.0,
+    "batch_size": 32,
+    "epochs": 30,
+    "patience": 10,
+    "max_glycan_length": 256,
+    "max_protein_length": 1024,
+    "protein_mode": "real",
+    "ranking_loss": false,
+    "assays_per_batch": 4,
+    "rows_per_assay": 8,
+    "protein_binding_channel": false,
+    "glycan_only": false,
+    "protein_attentive_pool": false,
+    "motif_additive_dim": 165,
+    "glycan_size_channel": false,
+    "seed": 42,
+    "roles_tsv": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_C_doubly_roles.tsv.gz",
+    "train_stratum": "fit_train",
+    "val_stratum": "val_doubly_cold",
+    "test_stratum": "val_doubly_cold",
+    "features_dir": "/work/ratul1/supantha/Bertint/data/review_affinose_glycan_features_20260824_r1",
+    "expected_train_rows": 406483,
+    "expected_val_rows": 3822,
+    "expected_test_rows": 3822,
+    "manifest_sha256": "mo_20260908_moC_doubly",
+    "cell_id": "mo_C_doubly_s42",
+    "input_hashes": "/work/ratul1/supantha/Bertint/manifests/affinose_input_hashes_moC_doubly_20260908.json",
+    "warmup_pct": 0.05,
+    "target_col": "target_rank",
+    "checkpoint_interval": 1,
+    "resume": false,
+    "pooling_mode": "mean",
+    "interaction_mode": "concat",
+    "no_cross_attention": false
+  },
+  "input_hashes": {
+    "csv": "e43e150423cb998a77037ad6d82c158a65431b59c46b168febf263ad36267df4",
+    "roles_tsv": "e82fb6d73d3ce3ff33e32bd0a8d2e81a0aa4b19b8819bf18339c4aa0382dc5fd",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "f6ec937bb55813139ed1b26e07953c95d78fd1fe99ccec1f03bb74c09b7960f5",
+      "val": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391",
+      "test": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391"
+    }
+  },
+  "roster_digests": {
+    "train": "f6ec937bb55813139ed1b26e07953c95d78fd1fe99ccec1f03bb74c09b7960f5",
+    "val": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391",
+    "test": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391"
+  },
+  "slurm_job_id": "12247962",
+  "slurm_array_task_id": "2",
+  "slurm_restart_count": null,
+  "node": "nova22-gpu-2",
+  "gpu": "NVIDIA A100 80GB PCIe"
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mo_20260908_mo_C_doubly_s42/results.json

@@ -0,0 +1,294 @@
+{
+  "task_type": "regression",
+  "architecture": "cross-attention=True pooling=mean interaction=concat + live Bertose",
+  "best_metric": 0.18989928027597247,
+  "best_metric_is": "validation",
+  "best_epoch": 5,
+  "early_stopped": true,
+  "epochs_ran": 16,
+  "test_metrics": {
+    "spearman": 0.23230760714549056,
+    "pearson": 0.22095870971679688,
+    "mse": 0.0810273140668869,
+    "macro_spearman": 0.18989928027597247,
+    "macro_assays_eligible": 218,
+    "macro_assays_total": 218
+  },
+  "test_loss": 0.08108399153376619,
+  "history": [
+    {
+      "epoch": 1,
+      "train_loss": 0.0820725598469075,
+      "val_loss": 0.07980532947306831,
+      "val_metrics": {
+        "spearman": 0.21861695636332937,
+        "pearson": 0.21602514386177063,
+        "mse": 0.07971526682376862,
+        "macro_spearman": 0.1879467160935374,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.600456921860401e-06,
+      "lr_head": 3.800228460930201e-05
+    },
+    {
+      "epoch": 2,
+      "train_loss": 0.07351148931354597,
+      "val_loss": 0.08033600815882286,
+      "val_metrics": {
+        "spearman": 0.2209620955843994,
+        "pearson": 0.22815755009651184,
+        "mse": 0.08022104948759079,
+        "macro_spearman": 0.18053212057010906,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.992405222215124e-06,
+      "lr_head": 4.996202611107562e-05
+    },
+    {
+      "epoch": 3,
+      "train_loss": 0.0686865865012365,
+      "val_loss": 0.08297244912634293,
+      "val_metrics": {
+        "spearman": 0.2323234331604067,
+        "pearson": 0.229558527469635,
+        "mse": 0.08294177800416946,
+        "macro_spearman": 0.18236981617035328,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.93179964821535e-06,
+      "lr_head": 4.9658998241076745e-05
+    },
+    {
+      "epoch": 4,
+      "train_loss": 0.06548485753726821,
+      "val_loss": 0.08214062657207251,
+      "val_metrics": {
+        "spearman": 0.21538099756417373,
+        "pearson": 0.21252787113189697,
+        "mse": 0.08202281594276428,
+        "macro_spearman": 0.17564361108553003,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.811328950051998e-06,
+      "lr_head": 4.905664475025999e-05
+    },
+    {
+      "epoch": 5,
+      "train_loss": 0.06347042579143139,
+      "val_loss": 0.07959065570806463,
+      "val_metrics": {
+        "spearman": 0.22659004415366746,
+        "pearson": 0.22342076897621155,
+        "mse": 0.07952506840229034,
+        "macro_spearman": 0.18600536931930212,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.632455478806839e-06,
+      "lr_head": 4.816227739403419e-05
+    },
+    {
+      "epoch": 6,
+      "train_loss": 0.06186302897038609,
+      "val_loss": 0.08108399153376619,
+      "val_metrics": {
+        "spearman": 0.23230760714549056,
+        "pearson": 0.22095870971679688,
+        "mse": 0.0810273140668869,
+        "macro_spearman": 0.18989928027597247,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.397350516112365e-06,
+      "lr_head": 4.698675258056182e-05
+    },
+    {
+      "epoch": 7,
+      "train_loss": 0.06046433661505199,
+      "val_loss": 0.08360768208901087,
+      "val_metrics": {
+        "spearman": 0.20523514826535216,
+        "pearson": 0.20831626653671265,
+        "mse": 0.0835791826248169,
+        "macro_spearman": 0.17609303468973836,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.108867917734062e-06,
+      "lr_head": 4.554433958867031e-05
+    },
+    {
+      "epoch": 8,
+      "train_loss": 0.05909844870552025,
+      "val_loss": 0.0824368055909872,
+      "val_metrics": {
+        "spearman": 0.20461729443087306,
+        "pearson": 0.20222266018390656,
+        "mse": 0.08249732106924057,
+        "macro_spearman": 0.17707328238386544,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 8.770509471627362e-06,
+      "lr_head": 4.385254735813681e-05
+    },
+    {
+      "epoch": 9,
+      "train_loss": 0.057828584789735946,
+      "val_loss": 0.08604417247697711,
+      "val_metrics": {
+        "spearman": 0.20312934852690515,
+        "pearson": 0.2025664895772934,
+        "mse": 0.08613406866788864,
+        "macro_spearman": 0.16849112239141736,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 8.3863823909755e-06,
+      "lr_head": 4.1931911954877495e-05
+    },
+    {
+      "epoch": 10,
+      "train_loss": 0.056629490814496,
+      "val_loss": 0.08503294388453166,
+      "val_metrics": {
+        "spearman": 0.20220513112798374,
+        "pearson": 0.20082733035087585,
+        "mse": 0.08514758199453354,
+        "macro_spearman": 0.16524417323252355,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.961149458185257e-06,
+      "lr_head": 3.9805747290926286e-05
+    },
+    {
+      "epoch": 11,
+      "train_loss": 0.05531735030949904,
+      "val_loss": 0.08600124850248297,
+      "val_metrics": {
+        "spearman": 0.198682925808775,
+        "pearson": 0.1959197223186493,
+        "mse": 0.08607515692710876,
+        "macro_spearman": 0.17737299060322365,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.499972425024911e-06,
+      "lr_head": 3.7499862125124546e-05
+    },
+    {
+      "epoch": 12,
+      "train_loss": 0.05402435923889215,
+      "val_loss": 0.09162988619258007,
+      "val_metrics": {
+        "spearman": 0.16928709292866903,
+        "pearson": 0.17052659392356873,
+        "mse": 0.09164858609437943,
+        "macro_spearman": 0.12841904491089645,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.008449355950063e-06,
+      "lr_head": 3.504224677975031e-05
+    },
+    {
+      "epoch": 13,
+      "train_loss": 0.052670215866714304,
+      "val_loss": 0.09579282198101283,
+      "val_metrics": {
+        "spearman": 0.15138558513405728,
+        "pearson": 0.15384550392627716,
+        "mse": 0.09586914628744125,
+        "macro_spearman": 0.12292897648647666,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 6.492546675184488e-06,
+      "lr_head": 3.246273337592243e-05
+    },
+    {
+      "epoch": 14,
+      "train_loss": 0.05133482151828506,
+      "val_loss": 0.0983895618778964,
+      "val_metrics": {
+        "spearman": 0.16096614573204776,
+        "pearson": 0.16646699607372284,
+        "mse": 0.09847484529018402,
+        "macro_spearman": 0.1471614747891466,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 5.958526742412386e-06,
+      "lr_head": 2.9792633712061927e-05
+    },
+    {
+      "epoch": 15,
+      "train_loss": 0.04995875641009164,
+      "val_loss": 0.10370649403582016,
+      "val_metrics": {
+        "spearman": 0.1388411585409256,
+        "pearson": 0.15041641891002655,
+        "mse": 0.10373455286026001,
+        "macro_spearman": 0.11630659583110417,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 5.412871836215041e-06,
+      "lr_head": 2.70643591810752e-05
+    },
+    {
+      "epoch": 16,
+      "train_loss": 0.04850863079172903,
+      "val_loss": 0.09986912375316023,
+      "val_metrics": {
+        "spearman": 0.1322993495504737,
+        "pearson": 0.13906846940517426,
+        "mse": 0.09997473657131195,
+        "macro_spearman": 0.10992753432795928,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 4.862205467989965e-06,
+      "lr_head": 2.431102733994982e-05
+    }
+  ],
+  "fingerprint": "20f398ef9542391b9fa12a01e6db7ad58ced7587299a05dfd707be73ddbb9ec6",
+  "input_hashes": {
+    "csv": "e43e150423cb998a77037ad6d82c158a65431b59c46b168febf263ad36267df4",
+    "roles_tsv": "e82fb6d73d3ce3ff33e32bd0a8d2e81a0aa4b19b8819bf18339c4aa0382dc5fd",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "f6ec937bb55813139ed1b26e07953c95d78fd1fe99ccec1f03bb74c09b7960f5",
+      "val": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391",
+      "test": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391"
+    }
+  }
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mof_20260909_mof_B_protein_s43/receipt.json

@@ -0,0 +1,101 @@
+{
+  "cell_id": "mof_B_protein_s43",
+  "fingerprint": "10fbf6df61355097aaa03b5b9db42822af419b2c1696866a589fca9efe80bbb9",
+  "manifest_sha256": "mof_20260909_moB_protein",
+  "args": {
+    "csv_path": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_B_protein_binding.csv",
+    "split_path": "/work/ratul1/supantha/Bertint/v2_artifacts/affinose_v2_splits_direct_edit_guarded.json",
+    "protein_emb_path": "/work/ratul1/supantha/Bertint/affinose_v2_esmc_by_seqhash_r2.h5",
+    "vocab_path": "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json",
+    "bertose_checkpoint": "/work/ratul1/supantha/bertose_a5_static_precache_20260723_r2c4_closure31_py310_3c8d5299a4af15bc/writing/review/multimodal/outputs/a5_wa345_pretraining_20260817_r1/production/review_md20x6_md20x6-a1111-wa345-20260817-r1_A1111_wa3_seed42/review_checkpoints/review_md20x6_checkpoint_best.pt",
+    "output_dir": "/work/ratul1/supantha/Bertint/checkpoints/affinose_mof_20260909_mof_B_protein_s43",
+    "freeze_layers": 4,
+    "shared_dim": 512,
+    "num_cross_layers": 2,
+    "num_heads": 8,
+    "swe_slices": 512,
+    "dropout": 0.1,
+    "protein_dim": 960,
+    "separate_swe": false,
+    "lr_encoder": 1e-05,
+    "lr_head": 5e-05,
+    "weight_decay": 0.01,
+    "max_grad_norm": 1.0,
+    "batch_size": 32,
+    "epochs": 30,
+    "patience": 10,
+    "max_glycan_length": 256,
+    "max_protein_length": 1024,
+    "protein_mode": "real",
+    "ranking_loss": false,
+    "assays_per_batch": 4,
+    "rows_per_assay": 8,
+    "protein_binding_channel": false,
+    "glycan_only": false,
+    "protein_attentive_pool": false,
+    "motif_additive_dim": 165,
+    "glycan_size_channel": false,
+    "seed": 43,
+    "roles_tsv": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_B_protein_roles.tsv.gz",
+    "train_stratum": "fit_train",
+    "val_stratum": "val_protein_cold",
+    "test_stratum": "val_protein_cold",
+    "features_dir": "/work/ratul1/supantha/Bertint/data/review_affinose_glycan_features_20260824_r1",
+    "expected_train_rows": 480431,
+    "expected_val_rows": 39477,
+    "expected_test_rows": 39477,
+    "manifest_sha256": "mof_20260909_moB_protein",
+    "cell_id": "mof_B_protein_s43",
+    "input_hashes": "/work/ratul1/supantha/Bertint/manifests/affinose_input_hashes_moB_protein_20260908.json",
+    "warmup_pct": 0.05,
+    "target_col": "target_rank",
+    "checkpoint_interval": 1,
+    "resume": false,
+    "pooling_mode": "mean",
+    "interaction_mode": "concat",
+    "no_cross_attention": false
+  },
+  "input_hashes": {
+    "csv": "db08ac7409ae5f119a706f8acb7c486154f10f70f59571fa7306178032ec6990",
+    "roles_tsv": "6ae90f6fed8e1874479b007d1537531b1a9f9f4db5a89855a9d48947ee0a88bc",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "fb872366d7c824122b62d484a9a90f41ac7b7998b4213bfbdc03702086090c27",
+      "val": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713",
+      "test": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713"
+    }
+  },
+  "roster_digests": {
+    "train": "fb872366d7c824122b62d484a9a90f41ac7b7998b4213bfbdc03702086090c27",
+    "val": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713",
+    "test": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713"
+  },
+  "slurm_job_id": "12252895",
+  "slurm_array_task_id": "0",
+  "slurm_restart_count": null,
+  "node": "nova20-amp-1",
+  "gpu": "NVIDIA A100-PCIE-40GB"
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mof_20260909_mof_B_protein_s43/results.json

@@ -0,0 +1,294 @@
+{
+  "task_type": "regression",
+  "architecture": "cross-attention=True pooling=mean interaction=concat + live Bertose",
+  "best_metric": 0.2616803241549893,
+  "best_metric_is": "validation",
+  "best_epoch": 5,
+  "early_stopped": true,
+  "epochs_ran": 16,
+  "test_metrics": {
+    "spearman": 0.26465318005549066,
+    "pearson": 0.28739896416664124,
+    "mse": 0.07721278071403503,
+    "macro_spearman": 0.2616803241549893,
+    "macro_assays_eligible": 246,
+    "macro_assays_total": 246
+  },
+  "test_loss": 0.07721429514265475,
+  "history": [
+    {
+      "epoch": 1,
+      "train_loss": 0.07954162840542994,
+      "val_loss": 0.07782782489325205,
+      "val_metrics": {
+        "spearman": 0.22831785172608393,
+        "pearson": 0.2535228133201599,
+        "mse": 0.0778268352150917,
+        "macro_spearman": 0.19343641142546214,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 7.600386589840024e-06,
+      "lr_head": 3.8001932949200124e-05
+    },
+    {
+      "epoch": 2,
+      "train_loss": 0.0705886414306581,
+      "val_loss": 0.07796654568281706,
+      "val_metrics": {
+        "spearman": 0.24540228051404406,
+        "pearson": 0.26456552743911743,
+        "mse": 0.0779670774936676,
+        "macro_spearman": 0.2274026008849437,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.992405590165015e-06,
+      "lr_head": 4.996202795082508e-05
+    },
+    {
+      "epoch": 3,
+      "train_loss": 0.06549934623372175,
+      "val_loss": 0.07865211885042091,
+      "val_metrics": {
+        "spearman": 0.25215879998564106,
+        "pearson": 0.2773054242134094,
+        "mse": 0.07865151017904282,
+        "macro_spearman": 0.2467353133105788,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.931800747491785e-06,
+      "lr_head": 4.965900373745893e-05
+    },
+    {
+      "epoch": 4,
+      "train_loss": 0.06254243126504527,
+      "val_loss": 0.07637372648575898,
+      "val_metrics": {
+        "spearman": 0.2581918487150839,
+        "pearson": 0.27826398611068726,
+        "mse": 0.0763733983039856,
+        "macro_spearman": 0.2570732451916451,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.811330767311252e-06,
+      "lr_head": 4.905665383655626e-05
+    },
+    {
+      "epoch": 5,
+      "train_loss": 0.06060447233149826,
+      "val_loss": 0.07684949162601822,
+      "val_metrics": {
+        "spearman": 0.2612953255933512,
+        "pearson": 0.2877562940120697,
+        "mse": 0.07684440910816193,
+        "macro_spearman": 0.25594701858636026,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.632457991989846e-06,
+      "lr_head": 4.816228995994923e-05
+    },
+    {
+      "epoch": 6,
+      "train_loss": 0.059014895508832266,
+      "val_loss": 0.07721429514265475,
+      "val_metrics": {
+        "spearman": 0.26465318005549066,
+        "pearson": 0.28739896416664124,
+        "mse": 0.07721278071403503,
+        "macro_spearman": 0.2616803241549893,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.397353694712487e-06,
+      "lr_head": 4.6986768473562434e-05
+    },
+    {
+      "epoch": 7,
+      "train_loss": 0.05770590116580162,
+      "val_loss": 0.07777405114817272,
+      "val_metrics": {
+        "spearman": 0.25557701527812,
+        "pearson": 0.2826829254627228,
+        "mse": 0.07777171581983566,
+        "macro_spearman": 0.25234290869807796,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.108871723167402e-06,
+      "lr_head": 4.554435861583701e-05
+    },
+    {
+      "epoch": 8,
+      "train_loss": 0.05641176031927989,
+      "val_loss": 0.07836433754391618,
+      "val_metrics": {
+        "spearman": 0.252197774483041,
+        "pearson": 0.2744917571544647,
+        "mse": 0.07836487889289856,
+        "macro_spearman": 0.25088632948434425,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 8.770513857701111e-06,
+      "lr_head": 4.385256928850556e-05
+    },
+    {
+      "epoch": 9,
+      "train_loss": 0.05523392668176769,
+      "val_loss": 0.07975887371350919,
+      "val_metrics": {
+        "spearman": 0.2480565658809454,
+        "pearson": 0.2695157825946808,
+        "mse": 0.07976102828979492,
+        "macro_spearman": 0.24774700422451598,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 8.386387304448665e-06,
+      "lr_head": 4.193193652224333e-05
+    },
+    {
+      "epoch": 10,
+      "train_loss": 0.05410393620964645,
+      "val_loss": 0.07961486578983899,
+      "val_metrics": {
+        "spearman": 0.24158881897101642,
+        "pearson": 0.265257865190506,
+        "mse": 0.07961051166057587,
+        "macro_spearman": 0.24260551808764666,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 7.961154839414931e-06,
+      "lr_head": 3.9805774197074656e-05
+    },
+    {
+      "epoch": 11,
+      "train_loss": 0.052832345262743496,
+      "val_loss": 0.07933218951217794,
+      "val_metrics": {
+        "spearman": 0.24484638376952045,
+        "pearson": 0.2682126760482788,
+        "mse": 0.07932918518781662,
+        "macro_spearman": 0.24749593452745058,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 7.4999782086902555e-06,
+      "lr_head": 3.749989104345127e-05
+    },
+    {
+      "epoch": 12,
+      "train_loss": 0.05168314740412603,
+      "val_loss": 0.08014735692396542,
+      "val_metrics": {
+        "spearman": 0.23723716672899273,
+        "pearson": 0.25973254442214966,
+        "mse": 0.08014728873968124,
+        "macro_spearman": 0.2429886585492663,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 7.008455471845214e-06,
+      "lr_head": 3.504227735922606e-05
+    },
+    {
+      "epoch": 13,
+      "train_loss": 0.05040372731105789,
+      "val_loss": 0.08099161927260737,
+      "val_metrics": {
+        "spearman": 0.2331638007735348,
+        "pearson": 0.2553894519805908,
+        "mse": 0.08098489046096802,
+        "macro_spearman": 0.23570626741202766,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 6.4925530490707626e-06,
+      "lr_head": 3.246276524535381e-05
+    },
+    {
+      "epoch": 14,
+      "train_loss": 0.04912812885086062,
+      "val_loss": 0.08161971862224117,
+      "val_metrics": {
+        "spearman": 0.23137538105705088,
+        "pearson": 0.24989166855812073,
+        "mse": 0.08161360770463943,
+        "macro_spearman": 0.23251248469650745,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 5.958533296919441e-06,
+      "lr_head": 2.97926664845972e-05
+    },
+    {
+      "epoch": 15,
+      "train_loss": 0.047906441031257345,
+      "val_loss": 0.08224580197095437,
+      "val_metrics": {
+        "spearman": 0.23034203959773117,
+        "pearson": 0.2500419318675995,
+        "mse": 0.08224118500947952,
+        "macro_spearman": 0.23809430388858327,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 5.41287849178004e-06,
+      "lr_head": 2.7064392458900194e-05
+    },
+    {
+      "epoch": 16,
+      "train_loss": 0.046632020503746034,
+      "val_loss": 0.08478603510841172,
+      "val_metrics": {
+        "spearman": 0.22068337270420055,
+        "pearson": 0.23975464701652527,
+        "mse": 0.08478289842605591,
+        "macro_spearman": 0.22897272805292576,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 4.862212143823363e-06,
+      "lr_head": 2.4311060719116812e-05
+    }
+  ],
+  "fingerprint": "10fbf6df61355097aaa03b5b9db42822af419b2c1696866a589fca9efe80bbb9",
+  "input_hashes": {
+    "csv": "db08ac7409ae5f119a706f8acb7c486154f10f70f59571fa7306178032ec6990",
+    "roles_tsv": "6ae90f6fed8e1874479b007d1537531b1a9f9f4db5a89855a9d48947ee0a88bc",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "fb872366d7c824122b62d484a9a90f41ac7b7998b4213bfbdc03702086090c27",
+      "val": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713",
+      "test": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713"
+    }
+  }
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mof_20260909_mof_B_protein_s44/receipt.json

@@ -0,0 +1,101 @@
+{
+  "cell_id": "mof_B_protein_s44",
+  "fingerprint": "b50035032c9c5017afd6328b7c1e4ab3f6ff7eeb8a1d126c918c5567e207115e",
+  "manifest_sha256": "mof_20260909_moB_protein",
+  "args": {
+    "csv_path": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_B_protein_binding.csv",
+    "split_path": "/work/ratul1/supantha/Bertint/v2_artifacts/affinose_v2_splits_direct_edit_guarded.json",
+    "protein_emb_path": "/work/ratul1/supantha/Bertint/affinose_v2_esmc_by_seqhash_r2.h5",
+    "vocab_path": "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json",
+    "bertose_checkpoint": "/work/ratul1/supantha/bertose_a5_static_precache_20260723_r2c4_closure31_py310_3c8d5299a4af15bc/writing/review/multimodal/outputs/a5_wa345_pretraining_20260817_r1/production/review_md20x6_md20x6-a1111-wa345-20260817-r1_A1111_wa3_seed42/review_checkpoints/review_md20x6_checkpoint_best.pt",
+    "output_dir": "/work/ratul1/supantha/Bertint/checkpoints/affinose_mof_20260909_mof_B_protein_s44",
+    "freeze_layers": 4,
+    "shared_dim": 512,
+    "num_cross_layers": 2,
+    "num_heads": 8,
+    "swe_slices": 512,
+    "dropout": 0.1,
+    "protein_dim": 960,
+    "separate_swe": false,
+    "lr_encoder": 1e-05,
+    "lr_head": 5e-05,
+    "weight_decay": 0.01,
+    "max_grad_norm": 1.0,
+    "batch_size": 32,
+    "epochs": 30,
+    "patience": 10,
+    "max_glycan_length": 256,
+    "max_protein_length": 1024,
+    "protein_mode": "real",
+    "ranking_loss": false,
+    "assays_per_batch": 4,
+    "rows_per_assay": 8,
+    "protein_binding_channel": false,
+    "glycan_only": false,
+    "protein_attentive_pool": false,
+    "motif_additive_dim": 165,
+    "glycan_size_channel": false,
+    "seed": 44,
+    "roles_tsv": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_B_protein_roles.tsv.gz",
+    "train_stratum": "fit_train",
+    "val_stratum": "val_protein_cold",
+    "test_stratum": "val_protein_cold",
+    "features_dir": "/work/ratul1/supantha/Bertint/data/review_affinose_glycan_features_20260824_r1",
+    "expected_train_rows": 480431,
+    "expected_val_rows": 39477,
+    "expected_test_rows": 39477,
+    "manifest_sha256": "mof_20260909_moB_protein",
+    "cell_id": "mof_B_protein_s44",
+    "input_hashes": "/work/ratul1/supantha/Bertint/manifests/affinose_input_hashes_moB_protein_20260908.json",
+    "warmup_pct": 0.05,
+    "target_col": "target_rank",
+    "checkpoint_interval": 1,
+    "resume": false,
+    "pooling_mode": "mean",
+    "interaction_mode": "concat",
+    "no_cross_attention": false
+  },
+  "input_hashes": {
+    "csv": "db08ac7409ae5f119a706f8acb7c486154f10f70f59571fa7306178032ec6990",
+    "roles_tsv": "6ae90f6fed8e1874479b007d1537531b1a9f9f4db5a89855a9d48947ee0a88bc",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "fb872366d7c824122b62d484a9a90f41ac7b7998b4213bfbdc03702086090c27",
+      "val": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713",
+      "test": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713"
+    }
+  },
+  "roster_digests": {
+    "train": "fb872366d7c824122b62d484a9a90f41ac7b7998b4213bfbdc03702086090c27",
+    "val": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713",
+    "test": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713"
+  },
+  "slurm_job_id": "12252896",
+  "slurm_array_task_id": "1",
+  "slurm_restart_count": null,
+  "node": "nova20-amp-1",
+  "gpu": "NVIDIA A100-PCIE-40GB"
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mof_20260909_mof_B_protein_s44/results.json

@@ -0,0 +1,324 @@
+{
+  "task_type": "regression",
+  "architecture": "cross-attention=True pooling=mean interaction=concat + live Bertose",
+  "best_metric": 0.2619743701834269,
+  "best_metric_is": "validation",
+  "best_epoch": 7,
+  "early_stopped": true,
+  "epochs_ran": 18,
+  "test_metrics": {
+    "spearman": 0.2522903089693993,
+    "pearson": 0.27707183361053467,
+    "mse": 0.07991175353527069,
+    "macro_spearman": 0.2619743701834269,
+    "macro_assays_eligible": 246,
+    "macro_assays_total": 246
+  },
+  "test_loss": 0.07990999335522735,
+  "history": [
+    {
+      "epoch": 1,
+      "train_loss": 0.07981738362739721,
+      "val_loss": 0.07805284763032773,
+      "val_metrics": {
+        "spearman": 0.22559178242900987,
+        "pearson": 0.2486092448234558,
+        "mse": 0.07805142551660538,
+        "macro_spearman": 0.20130664561426273,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 7.600386589840024e-06,
+      "lr_head": 3.8001932949200124e-05
+    },
+    {
+      "epoch": 2,
+      "train_loss": 0.07078751392609924,
+      "val_loss": 0.07947275961931898,
+      "val_metrics": {
+        "spearman": 0.24995568370609297,
+        "pearson": 0.28168702125549316,
+        "mse": 0.07947273552417755,
+        "macro_spearman": 0.23893393270644228,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.992405590165015e-06,
+      "lr_head": 4.996202795082508e-05
+    },
+    {
+      "epoch": 3,
+      "train_loss": 0.0660612302130991,
+      "val_loss": 0.07649334600554535,
+      "val_metrics": {
+        "spearman": 0.2534524155438286,
+        "pearson": 0.283633828163147,
+        "mse": 0.07649430632591248,
+        "macro_spearman": 0.25244388911037446,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.931800747491785e-06,
+      "lr_head": 4.965900373745893e-05
+    },
+    {
+      "epoch": 4,
+      "train_loss": 0.06302868131366045,
+      "val_loss": 0.07701158229068429,
+      "val_metrics": {
+        "spearman": 0.25958664299609535,
+        "pearson": 0.2883581519126892,
+        "mse": 0.07701101154088974,
+        "macro_spearman": 0.2571741323432227,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.811330767311252e-06,
+      "lr_head": 4.905665383655626e-05
+    },
+    {
+      "epoch": 5,
+      "train_loss": 0.06085977359548701,
+      "val_loss": 0.07774806868985319,
+      "val_metrics": {
+        "spearman": 0.25843513345166563,
+        "pearson": 0.28806793689727783,
+        "mse": 0.07775115966796875,
+        "macro_spearman": 0.25360786179010825,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.632457991989846e-06,
+      "lr_head": 4.816228995994923e-05
+    },
+    {
+      "epoch": 6,
+      "train_loss": 0.0592839516819901,
+      "val_loss": 0.07740682547208604,
+      "val_metrics": {
+        "spearman": 0.2630817552232598,
+        "pearson": 0.287427693605423,
+        "mse": 0.07740595936775208,
+        "macro_spearman": 0.26120600347796635,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.397353694712487e-06,
+      "lr_head": 4.6986768473562434e-05
+    },
+    {
+      "epoch": 7,
+      "train_loss": 0.057865291745236296,
+      "val_loss": 0.07692075606037047,
+      "val_metrics": {
+        "spearman": 0.25688249514777667,
+        "pearson": 0.28290003538131714,
+        "mse": 0.07692264020442963,
+        "macro_spearman": 0.2534613235639173,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 9.108871723167402e-06,
+      "lr_head": 4.554435861583701e-05
+    },
+    {
+      "epoch": 8,
+      "train_loss": 0.0565786789235537,
+      "val_loss": 0.07990999335522735,
+      "val_metrics": {
+        "spearman": 0.2522903089693993,
+        "pearson": 0.27707183361053467,
+        "mse": 0.07991175353527069,
+        "macro_spearman": 0.2619743701834269,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 8.770513857701111e-06,
+      "lr_head": 4.385256928850556e-05
+    },
+    {
+      "epoch": 9,
+      "train_loss": 0.05532620246784516,
+      "val_loss": 0.07763330655163411,
+      "val_metrics": {
+        "spearman": 0.25102246262105943,
+        "pearson": 0.2788107693195343,
+        "mse": 0.07763587683439255,
+        "macro_spearman": 0.2544694050064656,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 8.386387304448665e-06,
+      "lr_head": 4.193193652224333e-05
+    },
+    {
+      "epoch": 10,
+      "train_loss": 0.05405828924989818,
+      "val_loss": 0.07833248711337533,
+      "val_metrics": {
+        "spearman": 0.2438800982818175,
+        "pearson": 0.2745583653450012,
+        "mse": 0.07832974940538406,
+        "macro_spearman": 0.2523447986921982,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 7.961154839414931e-06,
+      "lr_head": 3.9805774197074656e-05
+    },
+    {
+      "epoch": 11,
+      "train_loss": 0.0528427298379628,
+      "val_loss": 0.08058726410056967,
+      "val_metrics": {
+        "spearman": 0.23660560596604926,
+        "pearson": 0.26180699467658997,
+        "mse": 0.08058898150920868,
+        "macro_spearman": 0.23424278398802012,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 7.4999782086902555e-06,
+      "lr_head": 3.749989104345127e-05
+    },
+    {
+      "epoch": 12,
+      "train_loss": 0.05164120228723162,
+      "val_loss": 0.07976167026538902,
+      "val_metrics": {
+        "spearman": 0.23261825638111633,
+        "pearson": 0.2558090090751648,
+        "mse": 0.07976232469081879,
+        "macro_spearman": 0.23266531292423337,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 7.008455471845214e-06,
+      "lr_head": 3.504227735922606e-05
+    },
+    {
+      "epoch": 13,
+      "train_loss": 0.0503626140305333,
+      "val_loss": 0.08149432827457423,
+      "val_metrics": {
+        "spearman": 0.2278419512374733,
+        "pearson": 0.2485179454088211,
+        "mse": 0.08149101585149765,
+        "macro_spearman": 0.23217940116093283,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 6.4925530490707626e-06,
+      "lr_head": 3.246276524535381e-05
+    },
+    {
+      "epoch": 14,
+      "train_loss": 0.04906632403745221,
+      "val_loss": 0.08259034495818847,
+      "val_metrics": {
+        "spearman": 0.21830880884551201,
+        "pearson": 0.24247127771377563,
+        "mse": 0.08259105682373047,
+        "macro_spearman": 0.22567405660753373,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 5.958533296919441e-06,
+      "lr_head": 2.97926664845972e-05
+    },
+    {
+      "epoch": 15,
+      "train_loss": 0.047798247342370724,
+      "val_loss": 0.0822906217340084,
+      "val_metrics": {
+        "spearman": 0.22129417925423603,
+        "pearson": 0.24620899558067322,
+        "mse": 0.08228731155395508,
+        "macro_spearman": 0.224604572584952,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 5.41287849178004e-06,
+      "lr_head": 2.7064392458900194e-05
+    },
+    {
+      "epoch": 16,
+      "train_loss": 0.046463664239008225,
+      "val_loss": 0.08506318003035829,
+      "val_metrics": {
+        "spearman": 0.2028253755057865,
+        "pearson": 0.2229027897119522,
+        "mse": 0.08505822718143463,
+        "macro_spearman": 0.21227674417314193,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 4.862212143823363e-06,
+      "lr_head": 2.4311060719116812e-05
+    },
+    {
+      "epoch": 17,
+      "train_loss": 0.0452233674025144,
+      "val_loss": 0.08821694987767181,
+      "val_metrics": {
+        "spearman": 0.20229581542185188,
+        "pearson": 0.22442831099033356,
+        "mse": 0.08821789920330048,
+        "macro_spearman": 0.20634215615444548,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 4.3132185965612014e-06,
+      "lr_head": 2.1566092982806e-05
+    },
+    {
+      "epoch": 18,
+      "train_loss": 0.04388836729720501,
+      "val_loss": 0.09027578428121981,
+      "val_metrics": {
+        "spearman": 0.193795332135738,
+        "pearson": 0.2129238247871399,
+        "mse": 0.09027887880802155,
+        "macro_spearman": 0.20139275176325294,
+        "macro_assays_eligible": 246,
+        "macro_assays_total": 246
+      },
+      "lr_encoder": 3.7725618879709492e-06,
+      "lr_head": 1.8862809439854746e-05
+    }
+  ],
+  "fingerprint": "b50035032c9c5017afd6328b7c1e4ab3f6ff7eeb8a1d126c918c5567e207115e",
+  "input_hashes": {
+    "csv": "db08ac7409ae5f119a706f8acb7c486154f10f70f59571fa7306178032ec6990",
+    "roles_tsv": "6ae90f6fed8e1874479b007d1537531b1a9f9f4db5a89855a9d48947ee0a88bc",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "fb872366d7c824122b62d484a9a90f41ac7b7998b4213bfbdc03702086090c27",
+      "val": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713",
+      "test": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713"
+    }
+  }
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mof_20260909_mof_C_doubly_s43/receipt.json

@@ -0,0 +1,101 @@
+{
+  "cell_id": "mof_C_doubly_s43",
+  "fingerprint": "788c8377637edb8cc4ba7bde154a1663f648db547dd0bc721c369dab7d8a8d5a",
+  "manifest_sha256": "mof_20260909_moC_doubly",
+  "args": {
+    "csv_path": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_C_doubly_binding.csv",
+    "split_path": "/work/ratul1/supantha/Bertint/v2_artifacts/affinose_v2_splits_direct_edit_guarded.json",
+    "protein_emb_path": "/work/ratul1/supantha/Bertint/affinose_v2_esmc_by_seqhash_r2.h5",
+    "vocab_path": "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json",
+    "bertose_checkpoint": "/work/ratul1/supantha/bertose_a5_static_precache_20260723_r2c4_closure31_py310_3c8d5299a4af15bc/writing/review/multimodal/outputs/a5_wa345_pretraining_20260817_r1/production/review_md20x6_md20x6-a1111-wa345-20260817-r1_A1111_wa3_seed42/review_checkpoints/review_md20x6_checkpoint_best.pt",
+    "output_dir": "/work/ratul1/supantha/Bertint/checkpoints/affinose_mof_20260909_mof_C_doubly_s43",
+    "freeze_layers": 4,
+    "shared_dim": 512,
+    "num_cross_layers": 2,
+    "num_heads": 8,
+    "swe_slices": 512,
+    "dropout": 0.1,
+    "protein_dim": 960,
+    "separate_swe": false,
+    "lr_encoder": 1e-05,
+    "lr_head": 5e-05,
+    "weight_decay": 0.01,
+    "max_grad_norm": 1.0,
+    "batch_size": 32,
+    "epochs": 30,
+    "patience": 10,
+    "max_glycan_length": 256,
+    "max_protein_length": 1024,
+    "protein_mode": "real",
+    "ranking_loss": false,
+    "assays_per_batch": 4,
+    "rows_per_assay": 8,
+    "protein_binding_channel": false,
+    "glycan_only": false,
+    "protein_attentive_pool": false,
+    "motif_additive_dim": 165,
+    "glycan_size_channel": false,
+    "seed": 43,
+    "roles_tsv": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_C_doubly_roles.tsv.gz",
+    "train_stratum": "fit_train",
+    "val_stratum": "val_doubly_cold",
+    "test_stratum": "val_doubly_cold",
+    "features_dir": "/work/ratul1/supantha/Bertint/data/review_affinose_glycan_features_20260824_r1",
+    "expected_train_rows": 406483,
+    "expected_val_rows": 3822,
+    "expected_test_rows": 3822,
+    "manifest_sha256": "mof_20260909_moC_doubly",
+    "cell_id": "mof_C_doubly_s43",
+    "input_hashes": "/work/ratul1/supantha/Bertint/manifests/affinose_input_hashes_moC_doubly_20260908.json",
+    "warmup_pct": 0.05,
+    "target_col": "target_rank",
+    "checkpoint_interval": 1,
+    "resume": false,
+    "pooling_mode": "mean",
+    "interaction_mode": "concat",
+    "no_cross_attention": false
+  },
+  "input_hashes": {
+    "csv": "e43e150423cb998a77037ad6d82c158a65431b59c46b168febf263ad36267df4",
+    "roles_tsv": "e82fb6d73d3ce3ff33e32bd0a8d2e81a0aa4b19b8819bf18339c4aa0382dc5fd",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "f6ec937bb55813139ed1b26e07953c95d78fd1fe99ccec1f03bb74c09b7960f5",
+      "val": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391",
+      "test": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391"
+    }
+  },
+  "roster_digests": {
+    "train": "f6ec937bb55813139ed1b26e07953c95d78fd1fe99ccec1f03bb74c09b7960f5",
+    "val": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391",
+    "test": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391"
+  },
+  "slurm_job_id": "12252897",
+  "slurm_array_task_id": "2",
+  "slurm_restart_count": null,
+  "node": "nova21-amp-3",
+  "gpu": "NVIDIA A100-PCIE-40GB"
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mof_20260909_mof_C_doubly_s43/results.json

@@ -0,0 +1,234 @@
+{
+  "task_type": "regression",
+  "architecture": "cross-attention=True pooling=mean interaction=concat + live Bertose",
+  "best_metric": 0.2278161550103475,
+  "best_metric_is": "validation",
+  "best_epoch": 1,
+  "early_stopped": true,
+  "epochs_ran": 12,
+  "test_metrics": {
+    "spearman": 0.24371231429579024,
+    "pearson": 0.24978864192962646,
+    "mse": 0.07957296073436737,
+    "macro_spearman": 0.2278161550103475,
+    "macro_assays_eligible": 218,
+    "macro_assays_total": 218
+  },
+  "test_loss": 0.07959918103491266,
+  "history": [
+    {
+      "epoch": 1,
+      "train_loss": 0.08217019368176276,
+      "val_loss": 0.080513754611214,
+      "val_metrics": {
+        "spearman": 0.18197313252266425,
+        "pearson": 0.19518351554870605,
+        "mse": 0.08036746084690094,
+        "macro_spearman": 0.13920416257310053,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.600456921860401e-06,
+      "lr_head": 3.800228460930201e-05
+    },
+    {
+      "epoch": 2,
+      "train_loss": 0.07321907142764479,
+      "val_loss": 0.07959918103491266,
+      "val_metrics": {
+        "spearman": 0.24371231429579024,
+        "pearson": 0.24978864192962646,
+        "mse": 0.07957296073436737,
+        "macro_spearman": 0.2278161550103475,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.992405222215124e-06,
+      "lr_head": 4.996202611107562e-05
+    },
+    {
+      "epoch": 3,
+      "train_loss": 0.06850780602590001,
+      "val_loss": 0.08010787678261598,
+      "val_metrics": {
+        "spearman": 0.22582728258155255,
+        "pearson": 0.22293958067893982,
+        "mse": 0.07997935265302658,
+        "macro_spearman": 0.18212787907544617,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.93179964821535e-06,
+      "lr_head": 4.9658998241076745e-05
+    },
+    {
+      "epoch": 4,
+      "train_loss": 0.06562513827228887,
+      "val_loss": 0.08135794155920545,
+      "val_metrics": {
+        "spearman": 0.20973701944665502,
+        "pearson": 0.2167285680770874,
+        "mse": 0.08122111111879349,
+        "macro_spearman": 0.1680262191228166,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.811328950051998e-06,
+      "lr_head": 4.905664475025999e-05
+    },
+    {
+      "epoch": 5,
+      "train_loss": 0.06357526822885308,
+      "val_loss": 0.08136990948890646,
+      "val_metrics": {
+        "spearman": 0.2147511192432372,
+        "pearson": 0.20993298292160034,
+        "mse": 0.0812588557600975,
+        "macro_spearman": 0.17879476431653582,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.632455478806839e-06,
+      "lr_head": 4.816227739403419e-05
+    },
+    {
+      "epoch": 6,
+      "train_loss": 0.06198898692786375,
+      "val_loss": 0.08343257292484244,
+      "val_metrics": {
+        "spearman": 0.1942465614715496,
+        "pearson": 0.19803641736507416,
+        "mse": 0.08329526335000992,
+        "macro_spearman": 0.1478931661753686,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.397350516112365e-06,
+      "lr_head": 4.698675258056182e-05
+    },
+    {
+      "epoch": 7,
+      "train_loss": 0.06052576813641251,
+      "val_loss": 0.08325061357269685,
+      "val_metrics": {
+        "spearman": 0.19448283762838364,
+        "pearson": 0.20482441782951355,
+        "mse": 0.08314784616231918,
+        "macro_spearman": 0.14600984283451282,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.108867917734062e-06,
+      "lr_head": 4.554433958867031e-05
+    },
+    {
+      "epoch": 8,
+      "train_loss": 0.059245914784017056,
+      "val_loss": 0.08221773185456792,
+      "val_metrics": {
+        "spearman": 0.21589636690321976,
+        "pearson": 0.22401371598243713,
+        "mse": 0.08215607702732086,
+        "macro_spearman": 0.19273642448412445,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 8.770509471627362e-06,
+      "lr_head": 4.385254735813681e-05
+    },
+    {
+      "epoch": 9,
+      "train_loss": 0.05797236338407353,
+      "val_loss": 0.08278422035897771,
+      "val_metrics": {
+        "spearman": 0.20207701461652208,
+        "pearson": 0.2028491199016571,
+        "mse": 0.08269399404525757,
+        "macro_spearman": 0.18161633571304941,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 8.3863823909755e-06,
+      "lr_head": 4.1931911954877495e-05
+    },
+    {
+      "epoch": 10,
+      "train_loss": 0.05678273152126263,
+      "val_loss": 0.08959366163859765,
+      "val_metrics": {
+        "spearman": 0.16949282307127173,
+        "pearson": 0.17482900619506836,
+        "mse": 0.08958856016397476,
+        "macro_spearman": 0.15269489273804726,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.961149458185257e-06,
+      "lr_head": 3.9805747290926286e-05
+    },
+    {
+      "epoch": 11,
+      "train_loss": 0.055409021762098595,
+      "val_loss": 0.08639660604918996,
+      "val_metrics": {
+        "spearman": 0.17912118331172416,
+        "pearson": 0.1813514530658722,
+        "mse": 0.08641572296619415,
+        "macro_spearman": 0.14887737256820655,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.499972425024911e-06,
+      "lr_head": 3.7499862125124546e-05
+    },
+    {
+      "epoch": 12,
+      "train_loss": 0.05418257805815219,
+      "val_loss": 0.09123583193868398,
+      "val_metrics": {
+        "spearman": 0.17283292579872125,
+        "pearson": 0.17656531929969788,
+        "mse": 0.0911729484796524,
+        "macro_spearman": 0.1595232903648669,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.008449355950063e-06,
+      "lr_head": 3.504224677975031e-05
+    }
+  ],
+  "fingerprint": "788c8377637edb8cc4ba7bde154a1663f648db547dd0bc721c369dab7d8a8d5a",
+  "input_hashes": {
+    "csv": "e43e150423cb998a77037ad6d82c158a65431b59c46b168febf263ad36267df4",
+    "roles_tsv": "e82fb6d73d3ce3ff33e32bd0a8d2e81a0aa4b19b8819bf18339c4aa0382dc5fd",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "f6ec937bb55813139ed1b26e07953c95d78fd1fe99ccec1f03bb74c09b7960f5",
+      "val": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391",
+      "test": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391"
+    }
+  }
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mof_20260909_mof_C_doubly_s44/receipt.json

@@ -0,0 +1,101 @@
+{
+  "cell_id": "mof_C_doubly_s44",
+  "fingerprint": "feb493f3bf5da120bfada3ab639b04a9e0cd89d0f00633e01c99a89664971d49",
+  "manifest_sha256": "mof_20260909_moC_doubly",
+  "args": {
+    "csv_path": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_C_doubly_binding.csv",
+    "split_path": "/work/ratul1/supantha/Bertint/v2_artifacts/affinose_v2_splits_direct_edit_guarded.json",
+    "protein_emb_path": "/work/ratul1/supantha/Bertint/affinose_v2_esmc_by_seqhash_r2.h5",
+    "vocab_path": "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json",
+    "bertose_checkpoint": "/work/ratul1/supantha/bertose_a5_static_precache_20260723_r2c4_closure31_py310_3c8d5299a4af15bc/writing/review/multimodal/outputs/a5_wa345_pretraining_20260817_r1/production/review_md20x6_md20x6-a1111-wa345-20260817-r1_A1111_wa3_seed42/review_checkpoints/review_md20x6_checkpoint_best.pt",
+    "output_dir": "/work/ratul1/supantha/Bertint/checkpoints/affinose_mof_20260909_mof_C_doubly_s44",
+    "freeze_layers": 4,
+    "shared_dim": 512,
+    "num_cross_layers": 2,
+    "num_heads": 8,
+    "swe_slices": 512,
+    "dropout": 0.1,
+    "protein_dim": 960,
+    "separate_swe": false,
+    "lr_encoder": 1e-05,
+    "lr_head": 5e-05,
+    "weight_decay": 0.01,
+    "max_grad_norm": 1.0,
+    "batch_size": 32,
+    "epochs": 30,
+    "patience": 10,
+    "max_glycan_length": 256,
+    "max_protein_length": 1024,
+    "protein_mode": "real",
+    "ranking_loss": false,
+    "assays_per_batch": 4,
+    "rows_per_assay": 8,
+    "protein_binding_channel": false,
+    "glycan_only": false,
+    "protein_attentive_pool": false,
+    "motif_additive_dim": 165,
+    "glycan_size_channel": false,
+    "seed": 44,
+    "roles_tsv": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_C_doubly_roles.tsv.gz",
+    "train_stratum": "fit_train",
+    "val_stratum": "val_doubly_cold",
+    "test_stratum": "val_doubly_cold",
+    "features_dir": "/work/ratul1/supantha/Bertint/data/review_affinose_glycan_features_20260824_r1",
+    "expected_train_rows": 406483,
+    "expected_val_rows": 3822,
+    "expected_test_rows": 3822,
+    "manifest_sha256": "mof_20260909_moC_doubly",
+    "cell_id": "mof_C_doubly_s44",
+    "input_hashes": "/work/ratul1/supantha/Bertint/manifests/affinose_input_hashes_moC_doubly_20260908.json",
+    "warmup_pct": 0.05,
+    "target_col": "target_rank",
+    "checkpoint_interval": 1,
+    "resume": false,
+    "pooling_mode": "mean",
+    "interaction_mode": "concat",
+    "no_cross_attention": false
+  },
+  "input_hashes": {
+    "csv": "e43e150423cb998a77037ad6d82c158a65431b59c46b168febf263ad36267df4",
+    "roles_tsv": "e82fb6d73d3ce3ff33e32bd0a8d2e81a0aa4b19b8819bf18339c4aa0382dc5fd",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "f6ec937bb55813139ed1b26e07953c95d78fd1fe99ccec1f03bb74c09b7960f5",
+      "val": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391",
+      "test": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391"
+    }
+  },
+  "roster_digests": {
+    "train": "f6ec937bb55813139ed1b26e07953c95d78fd1fe99ccec1f03bb74c09b7960f5",
+    "val": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391",
+    "test": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391"
+  },
+  "slurm_job_id": "12252894",
+  "slurm_array_task_id": "3",
+  "slurm_restart_count": null,
+  "node": "nova21-amp-3",
+  "gpu": "NVIDIA A100-PCIE-40GB"
+}

releases/2026-10-02/provenance/affinose_cells/affinose_mof_20260909_mof_C_doubly_s44/results.json

@@ -0,0 +1,264 @@
+{
+  "task_type": "regression",
+  "architecture": "cross-attention=True pooling=mean interaction=concat + live Bertose",
+  "best_metric": 0.21062218506431446,
+  "best_metric_is": "validation",
+  "best_epoch": 3,
+  "early_stopped": true,
+  "epochs_ran": 14,
+  "test_metrics": {
+    "spearman": 0.23531327082857056,
+    "pearson": 0.23060324788093567,
+    "mse": 0.08090551197528839,
+    "macro_spearman": 0.21062218506431446,
+    "macro_assays_eligible": 218,
+    "macro_assays_total": 218
+  },
+  "test_loss": 0.08097927542403341,
+  "history": [
+    {
+      "epoch": 1,
+      "train_loss": 0.0823811714034573,
+      "val_loss": 0.08316954768573244,
+      "val_metrics": {
+        "spearman": 0.19923863389392296,
+        "pearson": 0.20312944054603577,
+        "mse": 0.08306817710399628,
+        "macro_spearman": 0.14979364049573743,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.600456921860401e-06,
+      "lr_head": 3.800228460930201e-05
+    },
+    {
+      "epoch": 2,
+      "train_loss": 0.07352196992131037,
+      "val_loss": 0.08194014184797803,
+      "val_metrics": {
+        "spearman": 0.23002782642760716,
+        "pearson": 0.23304009437561035,
+        "mse": 0.08179230988025665,
+        "macro_spearman": 0.19135672277353788,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.992405222215124e-06,
+      "lr_head": 4.996202611107562e-05
+    },
+    {
+      "epoch": 3,
+      "train_loss": 0.06890469362752077,
+      "val_loss": 0.08131420062854885,
+      "val_metrics": {
+        "spearman": 0.2344376640032703,
+        "pearson": 0.23378324508666992,
+        "mse": 0.08125484734773636,
+        "macro_spearman": 0.19768865575292732,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.93179964821535e-06,
+      "lr_head": 4.9658998241076745e-05
+    },
+    {
+      "epoch": 4,
+      "train_loss": 0.06594055111535461,
+      "val_loss": 0.08097927542403341,
+      "val_metrics": {
+        "spearman": 0.23531327082857056,
+        "pearson": 0.23060324788093567,
+        "mse": 0.08090551197528839,
+        "macro_spearman": 0.21062218506431446,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.811328950051998e-06,
+      "lr_head": 4.905664475025999e-05
+    },
+    {
+      "epoch": 5,
+      "train_loss": 0.06386762665527351,
+      "val_loss": 0.08328413100292285,
+      "val_metrics": {
+        "spearman": 0.21344337077969475,
+        "pearson": 0.21080267429351807,
+        "mse": 0.08322741836309433,
+        "macro_spearman": 0.1906273111501897,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.632455478806839e-06,
+      "lr_head": 4.816227739403419e-05
+    },
+    {
+      "epoch": 6,
+      "train_loss": 0.062316317219027036,
+      "val_loss": 0.08544459746529659,
+      "val_metrics": {
+        "spearman": 0.21378404878560708,
+        "pearson": 0.21021392941474915,
+        "mse": 0.08542674779891968,
+        "macro_spearman": 0.1841262975097498,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.397350516112365e-06,
+      "lr_head": 4.698675258056182e-05
+    },
+    {
+      "epoch": 7,
+      "train_loss": 0.06089970052883347,
+      "val_loss": 0.08304940707360704,
+      "val_metrics": {
+        "spearman": 0.2142924318507679,
+        "pearson": 0.20584237575531006,
+        "mse": 0.08305490761995316,
+        "macro_spearman": 0.20147768236632793,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 9.108867917734062e-06,
+      "lr_head": 4.554433958867031e-05
+    },
+    {
+      "epoch": 8,
+      "train_loss": 0.05954349656158016,
+      "val_loss": 0.0856317674741149,
+      "val_metrics": {
+        "spearman": 0.20605229263914857,
+        "pearson": 0.20229709148406982,
+        "mse": 0.0855521708726883,
+        "macro_spearman": 0.15801575910924295,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 8.770509471627362e-06,
+      "lr_head": 4.385254735813681e-05
+    },
+    {
+      "epoch": 9,
+      "train_loss": 0.05828532947726342,
+      "val_loss": 0.09087766061226527,
+      "val_metrics": {
+        "spearman": 0.17898921602789444,
+        "pearson": 0.17833471298217773,
+        "mse": 0.0906767025589943,
+        "macro_spearman": 0.14823934961313195,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 8.3863823909755e-06,
+      "lr_head": 4.1931911954877495e-05
+    },
+    {
+      "epoch": 10,
+      "train_loss": 0.0570728823543768,
+      "val_loss": 0.08991672083114584,
+      "val_metrics": {
+        "spearman": 0.18307338675239052,
+        "pearson": 0.18055406212806702,
+        "mse": 0.08965384215116501,
+        "macro_spearman": 0.1408365513344764,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.961149458185257e-06,
+      "lr_head": 3.9805747290926286e-05
+    },
+    {
+      "epoch": 11,
+      "train_loss": 0.0557709243132436,
+      "val_loss": 0.09227961363891761,
+      "val_metrics": {
+        "spearman": 0.16599375190389218,
+        "pearson": 0.1591390073299408,
+        "mse": 0.09232576191425323,
+        "macro_spearman": 0.1580101290572493,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.499972425024911e-06,
+      "lr_head": 3.7499862125124546e-05
+    },
+    {
+      "epoch": 12,
+      "train_loss": 0.05454512665595613,
+      "val_loss": 0.09188498885681232,
+      "val_metrics": {
+        "spearman": 0.17033978684464768,
+        "pearson": 0.1680733561515808,
+        "mse": 0.09179382771253586,
+        "macro_spearman": 0.14625690534575364,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 7.008449355950063e-06,
+      "lr_head": 3.504224677975031e-05
+    },
+    {
+      "epoch": 13,
+      "train_loss": 0.0532016348550355,
+      "val_loss": 0.0945957535567383,
+      "val_metrics": {
+        "spearman": 0.15632833853849673,
+        "pearson": 0.15771374106407166,
+        "mse": 0.09457787126302719,
+        "macro_spearman": 0.14414718978591468,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 6.492546675184488e-06,
+      "lr_head": 3.246273337592243e-05
+    },
+    {
+      "epoch": 14,
+      "train_loss": 0.05184374296895343,
+      "val_loss": 0.09580712212870518,
+      "val_metrics": {
+        "spearman": 0.1508608569678843,
+        "pearson": 0.14708638191223145,
+        "mse": 0.09580221027135849,
+        "macro_spearman": 0.13152231787081284,
+        "macro_assays_eligible": 218,
+        "macro_assays_total": 218
+      },
+      "lr_encoder": 5.958526742412386e-06,
+      "lr_head": 2.9792633712061927e-05
+    }
+  ],
+  "fingerprint": "feb493f3bf5da120bfada3ab639b04a9e0cd89d0f00633e01c99a89664971d49",
+  "input_hashes": {
+    "csv": "e43e150423cb998a77037ad6d82c158a65431b59c46b168febf263ad36267df4",
+    "roles_tsv": "e82fb6d73d3ce3ff33e32bd0a8d2e81a0aa4b19b8819bf18339c4aa0382dc5fd",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "6f2ac53d3af2002a8eb42f3b4dc046659a261cdf6fe5eef158724c3527610949",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "f6ec937bb55813139ed1b26e07953c95d78fd1fe99ccec1f03bb74c09b7960f5",
+      "val": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391",
+      "test": "c537ff22ab74b5b6c6ec94e76ef3de2b6ffc1e17086c11657e5f29b0d88da391"
+    }
+  }
+}

releases/2026-10-02/provenance/affinose_cells/affinose_sa_20260908_mo_B_protein_s42/receipt.json

@@ -0,0 +1,101 @@
+{
+  "cell_id": "mo_B_protein_s42",
+  "fingerprint": "b01428c0a518f3d479eae47e01fb9f753829678e902ef19b2318139159d22b05",
+  "manifest_sha256": "mo_20260908_moB_protein",
+  "args": {
+    "csv_path": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_B_protein_binding.csv",
+    "split_path": "/work/ratul1/supantha/Bertint/v2_artifacts/affinose_v2_splits_direct_edit_guarded.json",
+    "protein_emb_path": "/work/ratul1/supantha/Bertint/affinose_v2_esmc_by_seqhash_r2.h5",
+    "vocab_path": "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/data/review_sequences_a5_non_iar_later_role_official_array_v4_20260721_r1/review_bpe_vocabulary.json",
+    "bertose_checkpoint": "/work/ratul1/supantha/bertose_a5_static_precache_20260723_r2c4_closure31_py310_3c8d5299a4af15bc/writing/review/multimodal/outputs/a5_wa345_pretraining_20260817_r1/production/review_md20x6_md20x6-a1111-wa345-20260817-r1_A1111_wa3_seed42/review_checkpoints/review_md20x6_checkpoint_best.pt",
+    "output_dir": "/work/ratul1/supantha/Bertint/checkpoints/affinose_sa_20260908_mo_B_protein_s42",
+    "freeze_layers": 4,
+    "shared_dim": 512,
+    "num_cross_layers": 2,
+    "num_heads": 8,
+    "swe_slices": 512,
+    "dropout": 0.1,
+    "protein_dim": 960,
+    "separate_swe": false,
+    "lr_encoder": 1e-05,
+    "lr_head": 5e-05,
+    "weight_decay": 0.01,
+    "max_grad_norm": 1.0,
+    "batch_size": 32,
+    "epochs": 30,
+    "patience": 10,
+    "max_glycan_length": 256,
+    "max_protein_length": 1024,
+    "protein_mode": "real",
+    "ranking_loss": false,
+    "assays_per_batch": 4,
+    "rows_per_assay": 8,
+    "protein_binding_channel": false,
+    "glycan_only": false,
+    "protein_attentive_pool": false,
+    "motif_additive_dim": 165,
+    "glycan_size_channel": false,
+    "seed": 42,
+    "roles_tsv": "/work/ratul1/supantha/Bertint/v2_artifacts/review_affinose_B_protein_roles.tsv.gz",
+    "train_stratum": "fit_train",
+    "val_stratum": "val_protein_cold",
+    "test_stratum": "val_protein_cold",
+    "features_dir": "/work/ratul1/supantha/Bertint/data/review_affinose_glycan_features_20260824_r1",
+    "expected_train_rows": 480431,
+    "expected_val_rows": 39477,
+    "expected_test_rows": 39477,
+    "manifest_sha256": "mo_20260908_moB_protein",
+    "cell_id": "mo_B_protein_s42",
+    "input_hashes": "/work/ratul1/supantha/Bertint/manifests/affinose_input_hashes_moB_protein_20260908.json",
+    "warmup_pct": 0.05,
+    "target_col": "target_rank",
+    "checkpoint_interval": 1,
+    "resume": false,
+    "pooling_mode": "mean",
+    "interaction_mode": "concat",
+    "no_cross_attention": false
+  },
+  "input_hashes": {
+    "csv": "db08ac7409ae5f119a706f8acb7c486154f10f70f59571fa7306178032ec6990",
+    "roles_tsv": "6ae90f6fed8e1874479b007d1537531b1a9f9f4db5a89855a9d48947ee0a88bc",
+    "protein_emb_h5": "529ae25ecac7c03d0fc33f8f52f6cacec2db5103f27088d25e9adc06133fdef4",
+    "vocabulary": "918c73a55adeb603614112d75bb02033e5823fd9c8a70d43f6c0a4a9c78e360b",
+    "upstream_checkpoint": "8e7d95ee492df6d843f495dd4708c97ee16a947e75b5cd8f83b23e4f4a0d6d82",
+    "dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+    "training_v8.py": "b7cb8a39e167f2cc9e35476dcdcad56320b02c1898d13db3236a41bbb2ed4852",
+    "bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+    "a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98",
+    "feature_token_ids": "9dbdf73149ce8a3a1d4e1a5322f8a3de68e0f2e1a2e6a73733641e02a9b32ccd",
+    "feature_branch_depths": "afa8b69797891b529b212da41726c1d1269e06f26396370e2fcc0b77f25a5086",
+    "feature_linkage_types": "3440fc0db96dc3ecdfa315e390fe354c398ded75db8b9017569db7bf6c61610f",
+    "feature_attention_mask": "43cdb6ccd9c5e5ecc46aed5ed0c29801144526486e89ba3f611537cea13e8282",
+    "feature_tree_channels_valid": "0c867a6e6fdf3a0b72d5fdb76023556d998ad286ef14f0f8f661d760b8f18a2c",
+    "feature_motif_features": "d88c2d1342d27f572a27ec030579341a59d72bad89d552695d4db419ff3ceae2",
+    "feature_index": "986c4282f79ba621afdd4ad8cfe58d29d79d819946e75d0eb2d9c2316d637a3d",
+    "_imported_modules": {
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/training_v8.py": "b7cb8a39e167f2cc9e35476dcdcad56320b02c1898d13db3236a41bbb2ed4852",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/bertint_v8.py": "4df5fcf330bbb4d7d766a141179a5fea76a4e75fc9eef0e403cb567d97dd4564",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/dataset_v8.py": "0cafa57d2b468e1c5ac9d0e9285565de05500fc78ebac467cd09aeceb0e1b6c4",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/glycan_bert.py": "b69f14c9976951325e3a0a4e8107a16126e67d410e966650f513f1f538a732bb",
+      "/work/ratul1/supantha/glycan-SD-VS/bert_training_v3/v3.1_cluster_training/bert_training_v4/model/multimodal_glycan_bert_v3.py": "83fde1c18cd6547a6ea026017296b5c94d209ac8f0e125057f03d507b3b65190",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a5_tokenizer_shim.py": "771759e04c6c8aabdb928c7a2396fc07af3aefb917b857e07c5c2a0dd77ae96e",
+      "/work/ratul1/supantha/Bertint/model_motif_20260908/a1111_encoder_adapter.py": "52c790c24e10061b5890260aad39cefdb6c2c615b8b9c167cc23d86393e41d98"
+    },
+    "_roster_digests": {
+      "train": "fb872366d7c824122b62d484a9a90f41ac7b7998b4213bfbdc03702086090c27",
+      "val": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713",
+      "test": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713"
+    }
+  },
+  "roster_digests": {
+    "train": "fb872366d7c824122b62d484a9a90f41ac7b7998b4213bfbdc03702086090c27",
+    "val": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713",
+    "test": "9f258e1549c5fc1d1f21a2204f0dbcc46b0f3af489f8845309bcc0d6a3e78713"
+  },
+  "slurm_job_id": "12246887",
+  "slurm_array_task_id": "1",
+  "slurm_restart_count": null,
+  "node": "nova22-amp-4",
+  "gpu": "NVIDIA A100-PCIE-40GB"
+}