Publish 9 pretraining and 27 complete source-selected models

Original October 2 weights, strict portable CPU loader, exact shared tokenizer, source-selected head and parent identities. No retraining or new benchmark scoring; no blanket weight license assigned.

ENVIRONMENT_NOTE.json

@@ -0,0 +1,10 @@
+{
+  "status": "observed_and_documented",
+  "torch_imported_version": "2.3.0+cu121",
+  "torch_cuda_build": "12.1",
+  "torch_distribution_metadata": "2.9.1",
+  "cpu_replay_imported_binary": "2.3.0+cu121",
+  "clean_environment_installation_validated": false,
+  "historical_training_binary_version_established": false,
+  "scope": "Current CPU portable-loader checks; distribution metadata is inconsistent with imported module. This addendum does not alter checkpoints, scientific scores or the frozen core."
+}

README.md

@@ -0,0 +1,167 @@
+---
+language:
+- en
+tags:
+- biology
+- protein
+- gpt2
+- reproducibility
+- research
+---
+
+# bio2nl: the 2026-10-02 model collection
+
+This package describes **9 freshly pretrained GPT-2-style models and 27 complete
+source-validation-selected protein-pair classifiers**. It includes the exact
+shared 32,000-entry BPE tokenizer, all configuration/provenance identities and an
+offline CPU loader. Weights are the original files, not converted or retrained.
+The model repository is `dnagpt/bio2nl-models`. Pin an immutable repository
+revision when downloading; the accompanying GitHub release records the verified commit.
+
+## Scope and scientific interpretation
+
+EP pretraining mixes English and natural protein, ES mixes the same English and
+residue-shuffled protein, and EE uses English plus additional English. Each run
+uses 16,777,216 input tokens and 1,024 updates. Each condition has three
+pretraining seeds. Each pretrained model has three source fine-tuning seeds.
+Fine-tuning uses 8,044 protein sequence-pair training examples for five epochs;
+minimum source validation cross-entropy selects the saved epoch, ties earlier.
+Every selected checkpoint includes the fine-tuned backbone and its original
+two-logit classifier head. No English pair labels trained or selected these heads.
+
+These are exploratory research models. Protein labels measure the experiment's
+operational sequence similarity, not verified structural or remote homology.
+The current EP source-test accuracy is about 50.8%; its English transfer results
+do not demonstrate reliable fixed-head sentence-similarity classification. A
+modest exploratory ranking difference is reported in the accompanying study.
+The CPU examples here are software checks, not new scientific evaluations.
+
+Source and result release:
+[GitHub immutable source](https://github.com/maris205/bio2nl/tree/0d91df978ab5ac8604a9216bb5a6036605aea910/releases/2026-10-03-v1/source)
+and [Hugging Face protein/code release](https://huggingface.co/datasets/dnagpt/bio2nl/tree/62ced1ec44444b1879f2c473c553e6b5a9c6767f/releases/2026-10-03-v1).
+
+## File identities and model identifiers
+
+The trusted `model_catalog.json` SHA-256 is:
+
+```
+5f6694f206084ad51dcc27c1485c4b4d000ffe5023310482aab367d0815df067
+```
+
+The catalog binds every file's size/SHA, complete tensor-state digest, backbone
+and head digests, full config, tokenizer, training protocol and prepared-data
+manifest. Classifier entries also bind the source-selected epoch and the exact
+pretraining parent. These hashes are independently projected from the frozen
+training/source-selection records; a digest merely declared by a checkpoint is
+not trusted.
+
+| Identifier | Artifact |
+|---|---|
+| `EP-pt0` | Pretrained causal LM, condition EP, pretraining seed 0 |
+| `EP-pt0-ft0` | Complete source-selected EP classifier, pretraining seed 0, fine-tuning seed 0 |
+| `ES-pt1-ft2` | Complete source-selected ES classifier, pretraining seed 1, fine-tuning seed 2 |
+
+Conditions are `EP`, `ES`, `EE`; both seed indices range from 0 to 2. All 36
+weights total **15,845,506,290 bytes**. One checkpoint is about 440 MB. A
+classifier is self-contained: its parent pretraining weight need not be downloaded
+for inference. `upload_mapping.json` is a maintainer inventory with relative
+original paths; it is not used by the public loader.
+
+## Download only the selected model
+
+Use the immutable model-repository commit recorded by the publication receipt.
+Download `inference.py`, `portable_core.py`, `model_catalog.json`, `config.json`,
+`tokenizer.json`, `example_pairs.json`, and one checkpoint, for example
+`checkpoints/source/EP/pt0/ft0/best.pt`. Preserve this relative layout. The
+`--checkpoint` option supports a differently located weight while keeping all
+digest and provenance checks.
+
+For example, after installing `huggingface_hub`:
+
+```python
+from huggingface_hub import snapshot_download
+
+snapshot_download(
+    repo_id="dnagpt/bio2nl-models",
+    revision="<immutable model-repository commit from the publication receipt>",
+    local_dir="bio2nl-models",
+    allow_patterns=["inference.py", "portable_core.py", "model_catalog.json",
+                    "config.json", "tokenizer.json", "example_pairs.json",
+                    "checkpoints/source/EP/pt0/ft0/best.pt"],
+)
+```
+
+## Offline verification and inference
+
+The CPU checks used Python 3.12.3 and imported PyTorch 2.3.0+cu121.
+The local distribution metadata incorrectly reported torch 2.9.1; see
+`ENVIRONMENT_NOTE.json`. The requirements describe the observed import versions,
+not a separately verified clean installation or a proven historical training binary.
+Run in the directory containing the downloaded package. No network, credentials,
+GPU, training acceptance, historical workspace path or benchmark examples are
+required by the inference commands.
+
+```bash
+python inference.py verify \
+  --catalog model_catalog.json \
+  --catalog-sha256 5f6694f206084ad51dcc27c1485c4b4d000ffe5023310482aab367d0815df067 \
+  --artifact-root . --model-id EP-pt0-ft0
+
+python inference.py predict \
+  --catalog model_catalog.json \
+  --catalog-sha256 5f6694f206084ad51dcc27c1485c4b4d000ffe5023310482aab367d0815df067 \
+  --artifact-root . --model-id EP-pt0-ft0 --pairs example_pairs.json
+```
+
+Input is a JSON list of objects with exactly `sentence1` and `sentence2`. The
+program refuses labels, empty endpoints, unknown/special content tokens, failed
+text roundtrips and hash/provenance mismatches. It independently caps each
+endpoint at 255 content tokens, emits `a + SEP + b + EOS`, right-pads with ID 0,
+and pools the last attention-mask-valid position. Output reports truncation,
+both log probabilities, probability for fixed label 1, the label-1 minus label-0
+margin, and uncalibrated argmax predictions (ties label 0). No polarity reversal,
+threshold adjustment, target calibration or pooling substitution occurs.
+
+`verify` also supports pretraining IDs such as `EP-pt0`; pair classification
+requires a `-ft` classifier. Programmatic `load_model` returns a standard
+`GPT2LMHeadModel` for a pretraining ID, or the complete `TransferClassifier`.
+
+The portable example uses **CPU FP32**. The study's held-out scoring used FP32
+weights with CUDA BF16 autocast. These regimes need not produce bitwise-equal
+scores. `cpu_replay_audit.json` checks the portable implementation against the
+original frozen implementation under the same CPU FP32 regime, using one source
+training protein pair and two handwritten English pairs. It does not recompute
+the study's benchmark tables.
+
+## Validation and maintenance
+
+`portable_core.py` is a byte-identical copy of the original frozen model module
+(SHA-256 `b2362edf8850fe20fbd23cc958a71f92ac2a187de4316f53f8750d3bca857592`).
+`catalog_build_audit.json` records independent file/state/config/finiteness
+verification of all 36 original checkpoints. `test_inference.py` covers file and
+catalog tampering, wrong parent/job/epoch/config, missing or malformed heads,
+nonfinite states, tokenizer tampering, path escapes and endpoint truncation.
+
+```bash
+python -m unittest discover -s . -p test_inference.py -v
+```
+
+`build_catalog.py` and `validate_cpu_replay.py` are maintainer-only provenance
+tools that take an explicit original workspace root. They are not needed by
+users loading this public package. No weight is copied by the catalog builder.
+
+## Data attribution and licensing status
+
+The protein inputs derive from UniProtKB/Swiss-Prot with sequence-source
+attribution in the accompanying protein release. English pretraining uses the
+documented OpenWebText selection. The experiment-generated shared BPE vocabulary
+was trained on 16 MiB each of English and protein training text; it is reused from
+the historical rebuilt v2 tokenizer. The tokenizer is not an independently
+trained model for every later holdout. Corpus membership and exposure limitations
+remain those described in the study and data card.
+
+**No model-weight license has been assigned in this release.** No license grant
+is inferred from training-data licenses or code provenance. Accordingly, this
+card deliberately omits the Hugging Face `license` metadata field. Public
+availability alone does not establish unrestricted redistribution or commercial
+use rights. Any later license assignment must be a separate documented change.

build_catalog.py

@@ -0,0 +1,141 @@
+"""Project original verified artifacts into a public path-independent catalog.
+
+Maintainer tool only: no network access and no weight copying. The upload map
+uses workspace-relative source paths and public repository-relative destinations.
+"""
+from __future__ import annotations
+
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import shutil
+
+import torch
+
+from inference import canonical_sha, file_sha, state_parts, require
+import portable_core as core
+
+
+TRAINING = Path("bio2nl/review/new_data_full_training_v1_2026-10-02")
+ASSETS = Path("release_staging/revision_2026-10-03_v1/source/metadata/models_assets.json")
+TOKENIZER = Path("data_rebuild/2026-10-01-portable-v2/tokenizers/mixed_bpe/tokenizer.json")
+
+
+def write(path, value):
+    require(not path.exists(), "Refuse to overwrite generated artifact")
+    path.write_text(json.dumps(value, indent=2, sort_keys=True, allow_nan=False) + "\n")
+
+
+def run(workspace, output):
+    workspace, output = Path(workspace).resolve(), Path(output).resolve()
+    output.mkdir(exist_ok=True, parents=True)
+    require(not (output / "model_catalog.json").exists(), "Catalog already exists")
+    assets = json.loads((workspace / ASSETS).read_text())
+    selection_path = workspace / TRAINING / "results/source_selection.json"
+    selection = json.loads(selection_path.read_text())
+    require(file_sha(selection_path) == assets["source_selection_sha256"], "Source selection digest differs")
+    require(selection["status"] == "frozen" and selection["conditions_filtered_by_score"] is False,
+            "Source selection was not frozen")
+    protocol_path = workspace / TRAINING / "protocol.json"
+    require(file_sha(protocol_path) == selection["protocol_sha256"], "Training protocol digest differs")
+    protocol = json.loads(protocol_path.read_text())
+    config = core.make_config(protocol["design"]).to_dict()
+    torch.set_num_threads(4)
+    selected = {(x["job"]["condition"], x["job"]["pt_seed"], x["job"]["ft_seed"]): x for x in selection["selected"]}
+    require(len(selected) == 27 and len(assets["files"]) == 36, "Incomplete model grid")
+    tokenizer_file = workspace / TOKENIZER
+    tokenizer_sha = file_sha(tokenizer_file)
+    require(tokenizer_sha == protocol["design"]["tokenizer"]["sha256"], "Shared tokenizer differs")
+    tokenizer_json = json.loads(tokenizer_file.read_text())
+    tokens = [x["content"] for x in sorted(tokenizer_json["added_tokens"], key=lambda x: x["id"])]
+    require(len(tokens) == 4, "Unexpected tokenizer special tokens")
+    catalog = {"schema_version": 1, "release_id": "bio2nl-2026-10-02-models-v1", "model_repository": "dnagpt/bio2nl-models",
+        "weight_license_status": "unassigned; no license grant is inferred from code or training-data licenses",
+        "training_protocol_sha256": selection["protocol_sha256"], "prepared_manifest_sha256": selection["prepared_manifest_sha256"],
+        "source_selection_sha256": file_sha(selection_path), "source_assets_manifest_sha256": file_sha(workspace / ASSETS),
+        "frozen_model_implementation_sha256": file_sha(workspace / TRAINING / "code_snapshot/model.py"),
+        "config": config, "config_canonical_sha256": canonical_sha(config),
+        "conditions": {"EP": "English + natural protein", "ES": "English + residue-shuffled protein", "EE": "English + additional English"},
+        "tokenizer": {"path": "tokenizer.json", "sha256": tokenizer_sha, "bytes": tokenizer_file.stat().st_size,
+                      "vocab_size": 32000, "special_tokens": tokens,
+                      "training_recipe": "Shared byte-level BPE trained on 16 MiB English and 16 MiB protein training text; historical v2 tokenizer reused"},
+        "inference": {"endpoint_cap": 255, "context_length": 512, "format": "a[:255] + [SEP=2] + b[:255] + [EOS=1]",
+                      "padding": "right, PAD=0", "pooling": "last attention-mask-valid token (EOS)",
+                      "score_direction": "label 1", "decision": "argmax; ties label 0", "calibration": "none",
+                      "reference_scoring_precision": "FP32 weights with CUDA BF16 autocast",
+                      "portable_example_precision": "CPU FP32; exact CUDA BF16 predictions are not promised"},
+        "models": []}
+    mapping = []
+    audit = []
+    by_id = {}
+    for asset in assets["files"]:
+        path = workspace / asset["path"]
+        require(path.stat().st_size == asset["bytes"] and file_sha(path) == asset["sha256"], "Original weight digest differs")
+        classifier = "ft_seed" in asset
+        condition, pt = asset["condition"], asset["pt_seed"]
+        model_id = f"{condition}-pt{pt}" + (f"-ft{asset['ft_seed']}" if classifier else "")
+        remote = f"checkpoints/source/{condition}/pt{pt}/ft{asset['ft_seed']}/best.pt" if classifier else f"checkpoints/pretrain/{condition}/pt{pt}/model.pt"
+        meta_path = path.parent / "metadata.json"
+        meta = json.loads(meta_path.read_text())
+        require(meta["status"] == "completed" and meta["run_kind"] == "full", "Incomplete original run")
+        payload = torch.load(path, map_location="cpu", weights_only=True, mmap=True)
+        kind = "source_classifier" if classifier else "causal_lm"
+        job = {"condition": condition, "pt_seed": pt, "smoke": False}
+        if classifier:
+            job["ft_seed"] = asset["ft_seed"]
+        require(payload["schema_version"] == 1 and payload["kind"] == kind and payload["metadata"]["job"] == job,
+                "Original checkpoint identity differs")
+        require(payload["metadata"]["protocol_sha256"] == selection["protocol_sha256"] and
+                payload["metadata"]["prepared_manifest_sha256"] == selection["prepared_manifest_sha256"], "Original provenance differs")
+        require(canonical_sha(payload["config"]) == canonical_sha(config), "Original complete config differs")
+        state = payload["state_dict"]
+        require(all(x.dtype == torch.float32 and torch.isfinite(x).all() for x in state.values()), "Invalid weight tensor")
+        digest = core.state_digest(state)
+        require(digest == payload["state_sha256"] == meta["checkpoint"]["state_sha256"], "Original state digest differs")
+        backbone, head = state_parts(state, kind)
+        entry = {"id": model_id, "kind": kind, "job": job,
+            "checkpoint": {"path": remote, "sha256": asset["sha256"], "bytes": asset["bytes"]},
+            "state_sha256": digest, "state_tensor_count": len(state), "backbone_state_sha256": backbone,
+            "head_state_sha256": head, "config_sha256": canonical_sha(config), "tokenizer_sha256": tokenizer_sha,
+            "training_result_sha256": file_sha(meta_path),
+            "head_description": "two-logit bias-free linear score.weight (2 x 768)" if classifier else "tied 32000 x 768 language-model output embedding"}
+        if classifier:
+            chosen = selected[(condition, pt, asset["ft_seed"])]
+            require(chosen["checkpoint"]["sha256"] == asset["sha256"] and chosen["checkpoint"]["state_sha256"] == digest and
+                    chosen["source_result"]["sha256"] == file_sha(meta_path), "Frozen selection differs")
+            require(payload["metadata"]["epoch"] == chosen["best_epoch"] == asset["best_epoch"] == meta["best_epoch"], "Selected epoch differs")
+            parent = by_id[f"{condition}-pt{pt}"]
+            require(meta["pretraining_checkpoint"]["sha256"] == parent["checkpoint"]["sha256"] and
+                    meta["pretraining_checkpoint"]["state_sha256"] == parent["state_sha256"] and
+                    meta["new_parent_backbone_exactly_inherited"] is True, "Parent link differs")
+            require(tuple(state["score.weight"].shape) == (2, 768), "Original classifier head differs")
+            entry.update(selected_epoch=chosen["best_epoch"], selection="minimum source validation CE; ties earlier epoch",
+                pretraining_parent={"id": parent["id"], "sha256": parent["checkpoint"]["sha256"], "state_sha256": parent["state_sha256"]})
+        else:
+            require(torch.equal(state["lm_head.weight"], state["transformer.wte.weight"]), "LM tied aliases differ")
+            entry.update(pretraining_steps=meta["updates"], input_tokens=meta["input_tokens"])
+        catalog["models"].append(entry)
+        by_id[model_id] = entry
+        mapping.append({"source_relative": asset["path"], "path_in_repo": remote, "sha256": asset["sha256"], "bytes": asset["bytes"]})
+        audit.append({"id": model_id, "file_verified": True, "state_verified": True, "config_verified": True,
+                      "finite_fp32": True, "source_selection_verified": classifier, "tensor_count": len(state)})
+        del payload, state
+        print("verified", model_id, flush=True)
+    shutil.copyfile(tokenizer_file, output / "tokenizer.json")
+    write(output / "config.json", config)
+    write(output / "model_catalog.json", catalog)
+    write(output / "upload_mapping.json", {"schema_version": 1, "model_repository": "dnagpt/bio2nl-models", "repo_type": "model",
+        "scope": "Existing original weights; no second weight copy; package support files added separately", "weights": mapping})
+    write(output / "catalog_build_audit.json", {"status": "passed", "completed_at_utc": datetime.now(timezone.utc).isoformat(),
+        "models": audit, "weight_files": len(mapping), "weight_bytes": sum(x["bytes"] for x in mapping),
+        "catalog_sha256": file_sha(output / "model_catalog.json"), "weight_files_copied": 0,
+        "trained_or_scored_benchmarks": False, "gpu_used": False})
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--workspace", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    run(args.workspace, args.output)

catalog_build_audit.json

@@ -0,0 +1,336 @@
+{
+  "catalog_sha256": "5f6694f206084ad51dcc27c1485c4b4d000ffe5023310482aab367d0815df067",
+  "completed_at_utc": "2026-10-03T08:13:32.395981+00:00",
+  "gpu_used": false,
+  "models": [
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt0",
+      "source_selection_verified": false,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt1",
+      "source_selection_verified": false,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt2",
+      "source_selection_verified": false,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt0",
+      "source_selection_verified": false,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt1",
+      "source_selection_verified": false,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt2",
+      "source_selection_verified": false,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt0",
+      "source_selection_verified": false,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt1",
+      "source_selection_verified": false,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt2",
+      "source_selection_verified": false,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt0-ft0",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt0-ft1",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt0-ft2",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt0-ft0",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt0-ft1",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt0-ft2",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt0-ft0",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt0-ft1",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt0-ft2",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt1-ft0",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt1-ft1",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt1-ft2",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt1-ft0",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt1-ft1",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt1-ft2",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt1-ft0",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt1-ft1",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt1-ft2",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt2-ft0",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt2-ft1",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EP-pt2-ft2",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt2-ft0",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt2-ft1",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "ES-pt2-ft2",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt2-ft0",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt2-ft1",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    },
+    {
+      "config_verified": true,
+      "file_verified": true,
+      "finite_fp32": true,
+      "id": "EE-pt2-ft2",
+      "source_selection_verified": true,
+      "state_verified": true,
+      "tensor_count": 149
+    }
+  ],
+  "status": "passed",
+  "trained_or_scored_benchmarks": false,
+  "weight_bytes": 15845506290,
+  "weight_files": 36,
+  "weight_files_copied": 0
+}

checkpoints/pretrain/EE/pt0/model.pt

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

checkpoints/pretrain/EE/pt1/model.pt

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

checkpoints/pretrain/EE/pt2/model.pt

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

checkpoints/pretrain/EP/pt0/model.pt

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

checkpoints/pretrain/EP/pt1/model.pt

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

checkpoints/pretrain/EP/pt2/model.pt

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

checkpoints/pretrain/ES/pt0/model.pt

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

checkpoints/pretrain/ES/pt1/model.pt

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

checkpoints/pretrain/ES/pt2/model.pt

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

checkpoints/source/EE/pt0/ft0/best.pt

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

checkpoints/source/EE/pt0/ft1/best.pt

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

checkpoints/source/EE/pt0/ft2/best.pt

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

checkpoints/source/EE/pt1/ft0/best.pt

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

checkpoints/source/EE/pt1/ft1/best.pt

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

checkpoints/source/EE/pt1/ft2/best.pt

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

checkpoints/source/EE/pt2/ft0/best.pt

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

checkpoints/source/EE/pt2/ft1/best.pt

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

checkpoints/source/EE/pt2/ft2/best.pt

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

checkpoints/source/EP/pt0/ft0/best.pt

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

checkpoints/source/EP/pt0/ft1/best.pt

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

checkpoints/source/EP/pt0/ft2/best.pt

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

checkpoints/source/EP/pt1/ft0/best.pt

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

checkpoints/source/EP/pt1/ft1/best.pt

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

checkpoints/source/EP/pt1/ft2/best.pt

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

checkpoints/source/EP/pt2/ft0/best.pt

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

checkpoints/source/EP/pt2/ft1/best.pt

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

checkpoints/source/EP/pt2/ft2/best.pt

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

checkpoints/source/ES/pt0/ft0/best.pt

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

checkpoints/source/ES/pt0/ft1/best.pt

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

checkpoints/source/ES/pt0/ft2/best.pt

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

checkpoints/source/ES/pt1/ft0/best.pt

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

checkpoints/source/ES/pt1/ft1/best.pt

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

checkpoints/source/ES/pt1/ft2/best.pt

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

checkpoints/source/ES/pt2/ft0/best.pt

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

checkpoints/source/ES/pt2/ft1/best.pt

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

checkpoints/source/ES/pt2/ft2/best.pt

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

config.json

@@ -0,0 +1,86 @@
+{
+  "_name_or_path": "",
+  "activation_function": "gelu_new",
+  "add_cross_attention": false,
+  "architectures": null,
+  "attn_pdrop": 0.1,
+  "bad_words_ids": null,
+  "begin_suppress_tokens": null,
+  "bos_token_id": 1,
+  "chunk_size_feed_forward": 0,
+  "cross_attention_hidden_size": null,
+  "decoder_start_token_id": null,
+  "diversity_penalty": 0.0,
+  "do_sample": false,
+  "early_stopping": false,
+  "embd_pdrop": 0.1,
+  "encoder_no_repeat_ngram_size": 0,
+  "eos_token_id": 1,
+  "exponential_decay_length_penalty": null,
+  "finetuning_task": null,
+  "forced_bos_token_id": null,
+  "forced_eos_token_id": null,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1"
+  },
+  "initializer_range": 0.02,
+  "is_decoder": false,
+  "is_encoder_decoder": false,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1
+  },
+  "layer_norm_epsilon": 1e-05,
+  "length_penalty": 1.0,
+  "max_length": 20,
+  "min_length": 0,
+  "model_type": "gpt2",
+  "n_ctx": 512,
+  "n_embd": 768,
+  "n_head": 12,
+  "n_inner": 3072,
+  "n_layer": 12,
+  "n_positions": 512,
+  "no_repeat_ngram_size": 0,
+  "num_beam_groups": 1,
+  "num_beams": 1,
+  "num_return_sequences": 1,
+  "output_attentions": false,
+  "output_hidden_states": false,
+  "output_scores": false,
+  "pad_token_id": 0,
+  "prefix": null,
+  "problem_type": null,
+  "pruned_heads": {},
+  "remove_invalid_values": false,
+  "reorder_and_upcast_attn": false,
+  "repetition_penalty": 1.0,
+  "resid_pdrop": 0.1,
+  "return_dict": true,
+  "return_dict_in_generate": false,
+  "scale_attn_by_inverse_layer_idx": false,
+  "scale_attn_weights": true,
+  "sep_token_id": null,
+  "summary_activation": null,
+  "summary_first_dropout": 0.1,
+  "summary_proj_to_labels": true,
+  "summary_type": "cls_index",
+  "summary_use_proj": true,
+  "suppress_tokens": null,
+  "task_specific_params": null,
+  "temperature": 1.0,
+  "tf_legacy_loss": false,
+  "tie_encoder_decoder": false,
+  "tie_word_embeddings": true,
+  "tokenizer_class": null,
+  "top_k": 50,
+  "top_p": 1.0,
+  "torch_dtype": null,
+  "torchscript": false,
+  "transformers_version": "4.45.2",
+  "typical_p": 1.0,
+  "use_bfloat16": false,
+  "use_cache": false,
+  "vocab_size": 32000
+}

cpu_replay_audit.json

@@ -0,0 +1,34 @@
+{
+  "all_encodings_exact": true,
+  "batch_size_1_vs_3_max_abs_log_probability_difference": 1.1920928955078125e-07,
+  "benchmark_scores_computed": false,
+  "catalog_sha256": "5f6694f206084ad51dcc27c1485c4b4d000ffe5023310482aab367d0815df067",
+  "classifier_id": "EP-pt0-ft0",
+  "classifier_max_abs_log_probability_difference": 0.0,
+  "classifier_predictions_exact": true,
+  "code_sha256": {
+    "inference.py": "43f5a1c770354b588b046ff02e4d03df4c13086224df4fba1285f8f2b3cf91ec",
+    "portable_core.py": "b2362edf8850fe20fbd23cc958a71f92ac2a187de4316f53f8750d3bca857592",
+    "validate_cpu_replay.py": "c8d232a6a386b6ce2a1d204887c0d582cd12d90b7988ed315158f1ed141f8ac4"
+  },
+  "completed_at_utc": "2026-10-03T08:22:48.747609+00:00",
+  "cpu_threads": 4,
+  "device": "cpu",
+  "examples": {
+    "handwritten_english_pairs": 2,
+    "source_training_protein_pairs": 1,
+    "source_training_row_id": "a4478a3375338815d4abef8adc599c5dd44affd5a4265ebb2a350890b8327e81"
+  },
+  "fixed_batch_padding_tolerance": 1e-05,
+  "gpu_used": false,
+  "limitation": "CPU FP32 replay validates portable loading/encoding. It does not promise bitwise equality with prior CUDA BF16 benchmark predictions.",
+  "optimizer_updates": 0,
+  "original_training_first_row_input_exact": true,
+  "portable_core_sha256": "b2362edf8850fe20fbd23cc958a71f92ac2a187de4316f53f8750d3bca857592",
+  "precision": "float32",
+  "pretraining_id": "EP-pt0",
+  "pretraining_max_abs_logit_difference": 0.0,
+  "reference_encoding_code_sha256": "c3e2f213da25ca7576a2875f77b33c9fa50b4ffc670a11c402d407708c9ee5bc",
+  "reference_model_code_sha256": "b2362edf8850fe20fbd23cc958a71f92ac2a187de4316f53f8750d3bca857592",
+  "status": "passed"
+}

example_pairs.json

@@ -0,0 +1,10 @@
+[
+  {
+    "sentence1": "A small bird sits beside the window.",
+    "sentence2": "A bird is sitting next to a window."
+  },
+  {
+    "sentence1": "The protein sequence is an experimental input.",
+    "sentence2": "The train leaves at noon."
+  }
+]

inference.py

@@ -0,0 +1,213 @@
+"""Offline CPU inference with independently pinned model catalog and artifacts.
+
+No downloads, training, benchmark scoring or workspace-dependent imports occur.
+The catalog digest must be obtained from a trusted release, not from a changed
+local catalog. Checkpoints are the original complete weights-only PyTorch files.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path, PurePosixPath
+import re
+
+import numpy as np
+import torch
+from tokenizers import Tokenizer
+
+import portable_core as core
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def canonical_sha(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()).hexdigest()
+
+
+def file_sha(path):
+    with Path(path).open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def safe_path(root, relative):
+    require(isinstance(relative, str) and relative and "\\" not in relative and "\0" not in relative,
+            "Invalid artifact path")
+    item = PurePosixPath(relative)
+    require(not item.is_absolute() and str(item) == relative and not any(x in ("", ".", "..") for x in item.parts),
+            "Artifact path must be canonical and relative")
+    root = Path(root).resolve()
+    target = (root / relative).resolve()
+    require(target.is_relative_to(root), "Artifact escapes artifact root")
+    return target
+
+
+def verify_file(path, descriptor):
+    require(Path(path).is_file() and Path(path).stat().st_size == descriptor["bytes"], "Artifact size differs")
+    require(file_sha(path) == descriptor["sha256"], "Artifact SHA-256 differs")
+
+
+def read_catalog(path, expected_sha256):
+    require(isinstance(expected_sha256, str) and re.fullmatch(r"[0-9a-f]{64}", expected_sha256),
+            "Trusted catalog SHA-256 is required")
+    raw = Path(path).read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == expected_sha256, "Catalog SHA-256 differs")
+    catalog = json.loads(raw)
+    require(catalog.get("schema_version") == 1 and catalog.get("release_id") == "bio2nl-2026-10-02-models-v1",
+            "Unknown model catalog")
+    entries = catalog["models"]
+    expected = {f"{c}-pt{p}" for c in ("EP", "ES", "EE") for p in range(3)}
+    expected |= {f"{c}-pt{p}-ft{f}" for c in ("EP", "ES", "EE") for p in range(3) for f in range(3)}
+    require(len(entries) == 36 and len({x["id"] for x in entries}) == 36 and {x["id"] for x in entries} == expected,
+            "Catalog model grid differs")
+    for entry in entries:
+        require(entry["config_sha256"] == canonical_sha(catalog["config"]), "Config identity differs")
+        require(entry["tokenizer_sha256"] == catalog["tokenizer"]["sha256"], "Tokenizer identity differs")
+        job = entry["job"]
+        classifier = entry["kind"] == "source_classifier"
+        require(entry["kind"] in ("causal_lm", "source_classifier") and job.get("smoke") is False,
+                "Unexpected checkpoint kind/job")
+        suffix = f"-ft{job['ft_seed']}" if classifier else ""
+        require(entry["id"] == f"{job['condition']}-pt{job['pt_seed']}" + suffix, "Model/job identity differs")
+        if classifier:
+            parents = [p for p in entries if p["id"] == entry["pretraining_parent"]["id"]]
+            require(len(parents) == 1, "Missing classifier parent")
+            parent = parents[0]
+            require(parent["kind"] == "causal_lm" and parent["job"]["condition"] == job["condition"] and
+                    parent["job"]["pt_seed"] == job["pt_seed"] and
+                    entry["pretraining_parent"]["sha256"] == parent["checkpoint"]["sha256"] and
+                    entry["pretraining_parent"]["state_sha256"] == parent["state_sha256"],
+                    "Classifier pretraining-parent provenance differs")
+            require(type(entry["selected_epoch"]) is int and 1 <= entry["selected_epoch"] <= 5,
+                    "Invalid source-selected epoch")
+    return catalog
+
+
+def select(catalog, model_id):
+    rows = [entry for entry in catalog["models"] if entry["id"] == model_id]
+    require(len(rows) == 1, "Unknown model identifier")
+    return rows[0]
+
+
+def load_tokenizer(catalog, artifact_root):
+    descriptor = catalog["tokenizer"]
+    path = safe_path(artifact_root, descriptor["path"])
+    verify_file(path, descriptor)
+    tokenizer = Tokenizer.from_file(str(path))
+    require(tokenizer.get_vocab_size() == 32000 and
+            [tokenizer.token_to_id(s) for s in descriptor["special_tokens"]] == [0, 1, 2, 3],
+            "Tokenizer vocabulary or special-token identities differ")
+    require(tokenizer.padding is None and tokenizer.truncation is None, "Unexpected tokenizer padding/truncation")
+    return tokenizer
+
+
+def state_parts(state, kind):
+    prefix = "transformer." if kind == "causal_lm" else "backbone."
+    backbone = {key[len(prefix):]: value for key, value in state.items() if key.startswith(prefix)}
+    head_name = "lm_head.weight" if kind == "causal_lm" else "score.weight"
+    require(backbone and head_name in state, "Incomplete backbone/head state")
+    return core.state_digest(backbone), core.state_digest({head_name: state[head_name]})
+
+
+def config_for_core(public_config):
+    """Restore integer-keyed config maps without mutating the public catalog."""
+    config = json.loads(json.dumps(public_config))
+    for field in ("id2label", "pruned_heads"):
+        config[field] = {int(key): value for key, value in config[field].items()}
+    return config
+
+
+def original_config_sha_after_load(config):
+    """Transformers 4.45.2 from_dict adds only this runtime key in-place."""
+    original = dict(config)
+    require(original.pop("attn_implementation", None) is None, "Unexpected injected attention implementation")
+    return canonical_sha(original)
+
+
+def load_model(catalog, model_id, artifact_root, checkpoint_override=None):
+    entry = select(catalog, model_id)
+    path = Path(checkpoint_override) if checkpoint_override is not None else safe_path(artifact_root, entry["checkpoint"]["path"])
+    require(path.stat().st_size == entry["checkpoint"]["bytes"], "Checkpoint size differs")
+    model, payload = core.load_checkpoint(path,
+        expected_sha256=entry["checkpoint"]["sha256"], expected_kind=entry["kind"], expected_job=entry["job"],
+        expected_state_sha256=entry["state_sha256"], expected_protocol_sha256=catalog["training_protocol_sha256"],
+        expected_manifest_sha256=catalog["prepared_manifest_sha256"], expected_epoch=entry.get("selected_epoch"),
+        expected_config=config_for_core(catalog["config"]))
+    require(original_config_sha_after_load(payload["config"]) == entry["config_sha256"], "Full checkpoint config differs")
+    backbone_sha, head_sha = state_parts(payload["state_dict"], entry["kind"])
+    require(backbone_sha == entry["backbone_state_sha256"] and head_sha == entry["head_state_sha256"],
+            "Backbone/head identity differs")
+    require(len(payload["state_dict"]) == entry["state_tensor_count"], "Tensor inventory differs")
+    if entry["kind"] == "source_classifier":
+        require(model.score.bias is None and tuple(model.score.weight.shape) == (2, 768), "Classifier head shape differs")
+    del payload
+    return model
+
+
+def encode_pairs(tokenizer, pairs):
+    require(isinstance(pairs, list) and pairs, "Supply at least one sentence pair")
+    ids = np.zeros((len(pairs), 512), dtype=np.int64)
+    masks = np.zeros_like(ids)
+    details = []
+    for index, pair in enumerate(pairs):
+        require(isinstance(pair, dict) and set(pair) == {"sentence1", "sentence2"},
+                "Each pair requires only sentence1 and sentence2; labels are not accepted")
+        original = []
+        for field in ("sentence1", "sentence2"):
+            text = pair[field]
+            require(isinstance(text, str) and bool(text), "Empty/nontext endpoint")
+            content = tokenizer.encode(text, add_special_tokens=False).ids
+            require(content and all(4 <= token < 32000 for token in content), "Unknown/special content token")
+            require(tokenizer.decode(content, skip_special_tokens=False) == text, "Text roundtrip failed")
+            original.append(content)
+        joined = original[0][:255] + [2] + original[1][:255] + [1]
+        ids[index, :len(joined)] = joined
+        masks[index, :len(joined)] = 1
+        details.append({"original_content_tokens": [len(x) for x in original],
+                        "truncated_endpoints": [len(x) > 255 for x in original], "encoded_length": len(joined)})
+    return {"input_ids": ids, "attention_mask": masks, "labels": np.zeros(len(pairs), dtype=np.int64)}, details
+
+
+def predict_pairs(model, tokenizer, pairs, batch_size=1):
+    arrays, details = encode_pairs(tokenizer, pairs)
+    predicted = core.predict_source(model, arrays, batch_size=batch_size, device="cpu", precision="float32")
+    values = []
+    for logp, pred, detail in zip(predicted["log_probabilities"], predicted["predictions"], details):
+        values.append({**detail, "log_probabilities": logp.tolist(), "probability_label_1": float(np.exp(logp[1])),
+                       "logit_margin_label_1_minus_0": float(logp[1] - logp[0]), "predicted_label": int(pred)})
+    return values
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("command", choices=("verify", "predict"))
+    parser.add_argument("--catalog", type=Path, required=True)
+    parser.add_argument("--catalog-sha256", required=True)
+    parser.add_argument("--artifact-root", type=Path, required=True)
+    parser.add_argument("--model-id", required=True, help="For example EP-pt0-ft0 or EP-pt0")
+    parser.add_argument("--checkpoint", type=Path, help="Explicit relocated checkpoint; all hashes still apply")
+    parser.add_argument("--pairs", type=Path, help="JSON array with sentence1/sentence2, without labels")
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--cpu-threads", type=int, default=4)
+    args = parser.parse_args()
+    require(args.cpu_threads > 0, "Invalid CPU thread count")
+    torch.set_num_threads(args.cpu_threads)
+    torch.set_float32_matmul_precision("highest")
+    catalog = read_catalog(args.catalog, args.catalog_sha256)
+    tokenizer = load_tokenizer(catalog, args.artifact_root)
+    model = load_model(catalog, args.model_id, args.artifact_root, args.checkpoint)
+    result = {"model_id": args.model_id, "checkpoint_sha256": select(catalog, args.model_id)["checkpoint"]["sha256"],
+              "catalog_sha256": args.catalog_sha256, "device": "cpu", "precision": "float32", "verified": True}
+    if args.command == "predict":
+        require(select(catalog, args.model_id)["kind"] == "source_classifier", "Pair inference requires a complete classifier")
+        require(args.pairs is not None, "--pairs is required for prediction")
+        result.update(fixed_direction="label_1", decision_rule="argmax_ties_label_0",
+                      predictions=predict_pairs(model, tokenizer, json.loads(args.pairs.read_text()), args.batch_size))
+    print(json.dumps(result, indent=2, allow_nan=False))
+
+
+if __name__ == "__main__":
+    main()

model_catalog.json

@@ -0,0 +1,1156 @@
+{
+  "conditions": {
+    "EE": "English + additional English",
+    "EP": "English + natural protein",
+    "ES": "English + residue-shuffled protein"
+  },
+  "config": {
+    "_name_or_path": "",
+    "activation_function": "gelu_new",
+    "add_cross_attention": false,
+    "architectures": null,
+    "attn_pdrop": 0.1,
+    "bad_words_ids": null,
+    "begin_suppress_tokens": null,
+    "bos_token_id": 1,
+    "chunk_size_feed_forward": 0,
+    "cross_attention_hidden_size": null,
+    "decoder_start_token_id": null,
+    "diversity_penalty": 0.0,
+    "do_sample": false,
+    "early_stopping": false,
+    "embd_pdrop": 0.1,
+    "encoder_no_repeat_ngram_size": 0,
+    "eos_token_id": 1,
+    "exponential_decay_length_penalty": null,
+    "finetuning_task": null,
+    "forced_bos_token_id": null,
+    "forced_eos_token_id": null,
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "initializer_range": 0.02,
+    "is_decoder": false,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "layer_norm_epsilon": 1e-05,
+    "length_penalty": 1.0,
+    "max_length": 20,
+    "min_length": 0,
+    "model_type": "gpt2",
+    "n_ctx": 512,
+    "n_embd": 768,
+    "n_head": 12,
+    "n_inner": 3072,
+    "n_layer": 12,
+    "n_positions": 512,
+    "no_repeat_ngram_size": 0,
+    "num_beam_groups": 1,
+    "num_beams": 1,
+    "num_return_sequences": 1,
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "output_scores": false,
+    "pad_token_id": 0,
+    "prefix": null,
+    "problem_type": null,
+    "pruned_heads": {},
+    "remove_invalid_values": false,
+    "reorder_and_upcast_attn": false,
+    "repetition_penalty": 1.0,
+    "resid_pdrop": 0.1,
+    "return_dict": true,
+    "return_dict_in_generate": false,
+    "scale_attn_by_inverse_layer_idx": false,
+    "scale_attn_weights": true,
+    "sep_token_id": null,
+    "summary_activation": null,
+    "summary_first_dropout": 0.1,
+    "summary_proj_to_labels": true,
+    "summary_type": "cls_index",
+    "summary_use_proj": true,
+    "suppress_tokens": null,
+    "task_specific_params": null,
+    "temperature": 1.0,
+    "tf_legacy_loss": false,
+    "tie_encoder_decoder": false,
+    "tie_word_embeddings": true,
+    "tokenizer_class": null,
+    "top_k": 50,
+    "top_p": 1.0,
+    "torch_dtype": null,
+    "torchscript": false,
+    "transformers_version": "4.45.2",
+    "typical_p": 1.0,
+    "use_bfloat16": false,
+    "use_cache": false,
+    "vocab_size": 32000
+  },
+  "config_canonical_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+  "frozen_model_implementation_sha256": "b2362edf8850fe20fbd23cc958a71f92ac2a187de4316f53f8750d3bca857592",
+  "inference": {
+    "calibration": "none",
+    "context_length": 512,
+    "decision": "argmax; ties label 0",
+    "endpoint_cap": 255,
+    "format": "a[:255] + [SEP=2] + b[:255] + [EOS=1]",
+    "padding": "right, PAD=0",
+    "pooling": "last attention-mask-valid token (EOS)",
+    "portable_example_precision": "CPU FP32; exact CUDA BF16 predictions are not promised",
+    "reference_scoring_precision": "FP32 weights with CUDA BF16 autocast",
+    "score_direction": "label 1"
+  },
+  "model_repository": "dnagpt/bio2nl-models",
+  "models": [
+    {
+      "backbone_state_sha256": "46847dccfcf055c1dffd61b49aab0788118c0f8cdb57f2985ef2121267a7923c",
+      "checkpoint": {
+        "bytes": 440148490,
+        "path": "checkpoints/pretrain/EP/pt0/model.pt",
+        "sha256": "f6d44eb163960891e8af7d4f701580c852534f3ab476d9b6c281903f3c329327"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "tied 32000 x 768 language-model output embedding",
+      "head_state_sha256": "864d94b74f04ec00873ad45ede838366f35715975b2c9b17a745862136d4692a",
+      "id": "EP-pt0",
+      "input_tokens": 16777216,
+      "job": {
+        "condition": "EP",
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "causal_lm",
+      "pretraining_steps": 1024,
+      "state_sha256": "246ecad3c16ba27a98e38fb99a8065dbe8b30514db32f080a088e4b7dc7197b9",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "45c54f2e63aed2ae8832a7372aa74a0309c0ebbea98eb8d938f2cc9ed044bb6a"
+    },
+    {
+      "backbone_state_sha256": "e69423b4455a141f87d42fb2093e683a124c59fb16c1b451f0ddcf7ebcbe6261",
+      "checkpoint": {
+        "bytes": 440148490,
+        "path": "checkpoints/pretrain/EP/pt1/model.pt",
+        "sha256": "09c034afc616d6ed529fe62af1c604a07e0bc64a32f58630908300caf250c44a"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "tied 32000 x 768 language-model output embedding",
+      "head_state_sha256": "79da0d94521174151af7cf2a4c834b264df5c4e862371934db74e95954305e9a",
+      "id": "EP-pt1",
+      "input_tokens": 16777216,
+      "job": {
+        "condition": "EP",
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "causal_lm",
+      "pretraining_steps": 1024,
+      "state_sha256": "75b547c5e431c1d995755d054a0b7aad403c2aaa463eedb1bdd38c634b098159",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "0aa1e7683afad1a5e325bc36d236227f26860694ac70afe33ca4335d14e80e44"
+    },
+    {
+      "backbone_state_sha256": "e01b2e73ef3b92dafca5230b73522e051129d2037ab41394e1d5eb306a63cb53",
+      "checkpoint": {
+        "bytes": 440148490,
+        "path": "checkpoints/pretrain/EP/pt2/model.pt",
+        "sha256": "a1285feb6eb6380bfedfe670a27e9f09b19163b33f76145cc008de0b1e223155"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "tied 32000 x 768 language-model output embedding",
+      "head_state_sha256": "0dde349ccabaaae961f360ba0b71811b4457dff2b9dd6c0e104b89e022f92b9b",
+      "id": "EP-pt2",
+      "input_tokens": 16777216,
+      "job": {
+        "condition": "EP",
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "causal_lm",
+      "pretraining_steps": 1024,
+      "state_sha256": "76e0af261c311b5bd49ffe47e72e7065d4f2405f1213222bff12cb42817f3f87",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "fa0385a030aeb97c295aa2bb7983dee396e9189f31aa5a4c19302c9862941567"
+    },
+    {
+      "backbone_state_sha256": "ba8e639f5618984aa88f011f3ef6c6de8eed57638a3a943fe3e47465bbb10e3d",
+      "checkpoint": {
+        "bytes": 440148490,
+        "path": "checkpoints/pretrain/ES/pt0/model.pt",
+        "sha256": "452c6178f682ae50e53c8df1311134e188c99d2fcce7805f0d65d379910f277d"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "tied 32000 x 768 language-model output embedding",
+      "head_state_sha256": "2c5d023746adbcb65f94caf6bae71fc5422e7faf9f445c539fb0e3117aab2f35",
+      "id": "ES-pt0",
+      "input_tokens": 16777216,
+      "job": {
+        "condition": "ES",
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "causal_lm",
+      "pretraining_steps": 1024,
+      "state_sha256": "53fc36f1cfcaedde896d0fce93d53c3040a670fb76a479311fb91c898f0af7ba",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "bbf0317458cc5b7bad58d3393d04fd0467fc72ea817551f4c97223eaa35e6dca"
+    },
+    {
+      "backbone_state_sha256": "7a9dde5809d278c9f48e263263ad833fe784b461aecb5419fc7f4d557fb4ab7e",
+      "checkpoint": {
+        "bytes": 440148490,
+        "path": "checkpoints/pretrain/ES/pt1/model.pt",
+        "sha256": "2f357c92c20c633a636f936246bfeadec31a9ee8792bfcaef1db2acf3ee1a737"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "tied 32000 x 768 language-model output embedding",
+      "head_state_sha256": "fefbb337fbd1d392b37b395cf2edb35a1e0e5ae072d021bbfb4c040efccd576a",
+      "id": "ES-pt1",
+      "input_tokens": 16777216,
+      "job": {
+        "condition": "ES",
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "causal_lm",
+      "pretraining_steps": 1024,
+      "state_sha256": "1da85f639f02e8a9a2fe41db83f7c951cef9a235466a340da3b4d94dfc2d8cfc",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "884f4cbb144127de4ce3e8dd01b78039a9fae95a199e5ba80eb3a8c5d7a16fd7"
+    },
+    {
+      "backbone_state_sha256": "7c9720e05764f2e9893191b12ae39c07ba7af8a55beacc1670a79add479a9c24",
+      "checkpoint": {
+        "bytes": 440148490,
+        "path": "checkpoints/pretrain/ES/pt2/model.pt",
+        "sha256": "e954373b086d2d3fe3b015440a185f4a146e01825007bc57cbcc609ed3d30254"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "tied 32000 x 768 language-model output embedding",
+      "head_state_sha256": "d55dd319963c2dff048185623ee3121ead803b0f3297c817d4358b119c1a53e4",
+      "id": "ES-pt2",
+      "input_tokens": 16777216,
+      "job": {
+        "condition": "ES",
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "causal_lm",
+      "pretraining_steps": 1024,
+      "state_sha256": "531f13ab25facf6a21f3a730dd3cbebc82d8f79aa24526fdde96f57dbd7097d9",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "f3ae824b0126b2d239cd8a25b4eebd5840a87507eedce3b9f4a83211d8b83bbb"
+    },
+    {
+      "backbone_state_sha256": "cc03cacccecd691268649146d0f709f6b4548463727d9fb61cba69b9ae43a761",
+      "checkpoint": {
+        "bytes": 440148490,
+        "path": "checkpoints/pretrain/EE/pt0/model.pt",
+        "sha256": "5af7730f436af372a0d43bfed57f87a3ea2e6aa4826493aa21eacd3acdd4dccc"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "tied 32000 x 768 language-model output embedding",
+      "head_state_sha256": "f3c5b803b261a26cfc969c726871427ee9771169b2eec9eb3981e3fcc04a096f",
+      "id": "EE-pt0",
+      "input_tokens": 16777216,
+      "job": {
+        "condition": "EE",
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "causal_lm",
+      "pretraining_steps": 1024,
+      "state_sha256": "be2793719f6a9cbd4d15528e4c0295d8a1558eb7b0ecf098eceb00c2cee35ecd",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "08c64e01c921c313f60272c8ff6cfb4f7a77909662de43b2af6ad52ed6305838"
+    },
+    {
+      "backbone_state_sha256": "1677dae3fcded88212e65045cb9399548e6e6b1a364cf44e85785ee78626a4c2",
+      "checkpoint": {
+        "bytes": 440148490,
+        "path": "checkpoints/pretrain/EE/pt1/model.pt",
+        "sha256": "653a88903ee373e5b8933c71d386a64ca6840249f9a42cc2c992b0202f04739f"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "tied 32000 x 768 language-model output embedding",
+      "head_state_sha256": "b99147643f7a4bb91fc7ea39edae68ec4d9015b767e92c7a9cfec47bf5b8943e",
+      "id": "EE-pt1",
+      "input_tokens": 16777216,
+      "job": {
+        "condition": "EE",
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "causal_lm",
+      "pretraining_steps": 1024,
+      "state_sha256": "2081069fd01c7c0d80bea6899bab92996f17480b375d625edb1e7095445ac622",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "d0dff9e41c053c0983a5bc952898265f24edd35d0baea47b28a5aa6c7b4dfe81"
+    },
+    {
+      "backbone_state_sha256": "aee2a29f1a4a6ce76ed3fa124f85cc39ba1aa317fc2970e4a692ee4dcec75209",
+      "checkpoint": {
+        "bytes": 440148490,
+        "path": "checkpoints/pretrain/EE/pt2/model.pt",
+        "sha256": "68e49c6af5cb3fa34b1820925cb1751055c38c25de8122b5ba19a40937ad0ba9"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "tied 32000 x 768 language-model output embedding",
+      "head_state_sha256": "a1bfc20e2807ee202e50a6e4f474054e11fcc2e10e9659bc9b75fbc70cfb06a7",
+      "id": "EE-pt2",
+      "input_tokens": 16777216,
+      "job": {
+        "condition": "EE",
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "causal_lm",
+      "pretraining_steps": 1024,
+      "state_sha256": "7b2de62c97d190cced9341476a36d0d281805c6f163f908099e7b600582897ea",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "85817c18ccea3f2d1b1f2780a92901903f775a1362f8c3be3892886ad51863d3"
+    },
+    {
+      "backbone_state_sha256": "723965894f5d1ee4ddb6071944bdef3901ee9305d6d40441a86db67f0124a79b",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EP/pt0/ft0/best.pt",
+        "sha256": "574117f9bbbaa589a0f1fd726567ead899510c05bcbcc0cbf71e3b57c72edebb"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "ce0e964f2bdcb9af6c77b5c0af05ae1e90472c95aa33d77676c59b3c7f195ee1",
+      "id": "EP-pt0-ft0",
+      "job": {
+        "condition": "EP",
+        "ft_seed": 0,
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EP-pt0",
+        "sha256": "f6d44eb163960891e8af7d4f701580c852534f3ab476d9b6c281903f3c329327",
+        "state_sha256": "246ecad3c16ba27a98e38fb99a8065dbe8b30514db32f080a088e4b7dc7197b9"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "2d7c592dbb1825cdfcf7b62b50e2e238784724c722d2207b4a8af0ea937a152f",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "1caa48707e014ce011a873819c9c90261d0be643b7a4d0cdf12f843327cf7578"
+    },
+    {
+      "backbone_state_sha256": "f6ff607c6203d848701c1f8f465c0590f6514a4baa27aa6f24376bd9b06f2522",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EP/pt0/ft1/best.pt",
+        "sha256": "a5c9522ed086bb54ce62ca74717c130143cfe07352b07a698529f1bedb497b6c"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "b2f08aae473191eb7e30dac84c48ad119f52899623b64a1df34cc52d297b9e97",
+      "id": "EP-pt0-ft1",
+      "job": {
+        "condition": "EP",
+        "ft_seed": 1,
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EP-pt0",
+        "sha256": "f6d44eb163960891e8af7d4f701580c852534f3ab476d9b6c281903f3c329327",
+        "state_sha256": "246ecad3c16ba27a98e38fb99a8065dbe8b30514db32f080a088e4b7dc7197b9"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "03fec3d6542957306b1cd01e19b852e3ec8e94642c761ae27adc62b1c0cc7247",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "604ba22dc8da9abded55361e192ef3984c4b3052086795091e449b894a1af9df"
+    },
+    {
+      "backbone_state_sha256": "acfac562250062feb6aa69a5d604ba235b56b47cc6ac14590da6ff414df61dd9",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EP/pt0/ft2/best.pt",
+        "sha256": "19277d64bb879906e98df99d1c77623c46d8ccad2c33eda796ba1b9bcd4cf3b5"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "b6216d87f9855cf295082ece2b0d8c5f22477c475598ea24f80c9fba74df36b9",
+      "id": "EP-pt0-ft2",
+      "job": {
+        "condition": "EP",
+        "ft_seed": 2,
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EP-pt0",
+        "sha256": "f6d44eb163960891e8af7d4f701580c852534f3ab476d9b6c281903f3c329327",
+        "state_sha256": "246ecad3c16ba27a98e38fb99a8065dbe8b30514db32f080a088e4b7dc7197b9"
+      },
+      "selected_epoch": 5,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "3d57d437443593afa95af3cbb64afbb0648c56d6b4f4d7afb8ce37621dff3b11",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "4b5207bad2e467064b9ca25d9cf498dcff1e458bedfd79dba01efab7882bdecd"
+    },
+    {
+      "backbone_state_sha256": "5c8397b6f4c4961d34e03072aa0f91871312f0c02e8967dd7c6f2bb09ca85795",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/ES/pt0/ft0/best.pt",
+        "sha256": "69069d19cade14739612d991743be14f3debe97e8c8cf48379810bed1498e913"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "2bd44f45605a18f99d3b6e96431ad800ffec52839704eafcfd49c9a264b046b6",
+      "id": "ES-pt0-ft0",
+      "job": {
+        "condition": "ES",
+        "ft_seed": 0,
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "ES-pt0",
+        "sha256": "452c6178f682ae50e53c8df1311134e188c99d2fcce7805f0d65d379910f277d",
+        "state_sha256": "53fc36f1cfcaedde896d0fce93d53c3040a670fb76a479311fb91c898f0af7ba"
+      },
+      "selected_epoch": 1,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "aa1e0fa9bc5db4d86a54955d54a3346b1757a3da807489c796b808487f647131",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "00f8407bd63ca5f6c317c4c43fb82f266efb82fb96e546d066cddbec1ebfb26b"
+    },
+    {
+      "backbone_state_sha256": "57b2db2c96583382e7a49ec85474d377cf8555815cb717cc4720cc138576711d",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/ES/pt0/ft1/best.pt",
+        "sha256": "bde6f1f919b7f5657edb0edb920941df3db8a88dd44089acd05b6b89c29c19be"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "1bbe058fde769286e8a0611f2b789bf1425e770de7c1319438b4f93b4626c6d1",
+      "id": "ES-pt0-ft1",
+      "job": {
+        "condition": "ES",
+        "ft_seed": 1,
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "ES-pt0",
+        "sha256": "452c6178f682ae50e53c8df1311134e188c99d2fcce7805f0d65d379910f277d",
+        "state_sha256": "53fc36f1cfcaedde896d0fce93d53c3040a670fb76a479311fb91c898f0af7ba"
+      },
+      "selected_epoch": 2,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "4ea04eb3dcaf63935cb0e377d2489a5126c987cdcd4bf2350ccf5c2f2b0ae8f8",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "23032955f58927fb361524d180a546af201e1b46b5d8e2ad58e4d08c109a0cb5"
+    },
+    {
+      "backbone_state_sha256": "a45ce8b281d893d86c0d1fcae7eaff9cc2c6e0a60b05a9064195e9eafc915979",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/ES/pt0/ft2/best.pt",
+        "sha256": "ec82de031e16af6005b1221327e6b58f9b8d1dc8f1a0072325a33453575b3b51"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "ff98005b3c9f32818e3315544ee5b359ea2086116b8461b95e2516696f193adb",
+      "id": "ES-pt0-ft2",
+      "job": {
+        "condition": "ES",
+        "ft_seed": 2,
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "ES-pt0",
+        "sha256": "452c6178f682ae50e53c8df1311134e188c99d2fcce7805f0d65d379910f277d",
+        "state_sha256": "53fc36f1cfcaedde896d0fce93d53c3040a670fb76a479311fb91c898f0af7ba"
+      },
+      "selected_epoch": 2,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "fe232820c5a890ca2358bb63b1a56f67e15036c47bafbc178ddc48f55e0661d8",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "b2b434faadb87ddc9158dcddfbd3d03b7dff3c3a022bbbfeb99e74f48c9ba450"
+    },
+    {
+      "backbone_state_sha256": "3728d8e1d773d2160557e98192a815861fce61991957be1bf6a546c9a69a6ddc",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EE/pt0/ft0/best.pt",
+        "sha256": "c1aa8820704665541550d7f59fed367c30dcc55b60c90f4ea2dcec75dce4103e"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "b0b0bf2750b6c488a9ef24e88b2e5ea979d4cfe29697c799f1b27469e5efca1f",
+      "id": "EE-pt0-ft0",
+      "job": {
+        "condition": "EE",
+        "ft_seed": 0,
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EE-pt0",
+        "sha256": "5af7730f436af372a0d43bfed57f87a3ea2e6aa4826493aa21eacd3acdd4dccc",
+        "state_sha256": "be2793719f6a9cbd4d15528e4c0295d8a1558eb7b0ecf098eceb00c2cee35ecd"
+      },
+      "selected_epoch": 1,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "1757b63b89c41333c8c4fed755a57f0c1d6c27954bb6d628bd89cfb5aaad085d",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "12f42581fe70e1f537e3abaa9b74ce92bc9b25f13eed5dbc742b3c088d55a1e0"
+    },
+    {
+      "backbone_state_sha256": "59013342320d1d7a743a495be78711fec93341047e644e0c1faa8263d6fd71f8",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EE/pt0/ft1/best.pt",
+        "sha256": "2a3ac91f4392196e836221e0435388b0e6ecae6c117be26f2b43de3e6507c4a1"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "f4ddd3d3da12ee2830aea75ddfc039db98553b21287ec5464faa66bcc054e084",
+      "id": "EE-pt0-ft1",
+      "job": {
+        "condition": "EE",
+        "ft_seed": 1,
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EE-pt0",
+        "sha256": "5af7730f436af372a0d43bfed57f87a3ea2e6aa4826493aa21eacd3acdd4dccc",
+        "state_sha256": "be2793719f6a9cbd4d15528e4c0295d8a1558eb7b0ecf098eceb00c2cee35ecd"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "34db029a40eef36d13cd998b60134d40d14faf7734616f3e2a7bab6ea732b17e",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "3d30522a8ae34c545eb0d5629804232b1c8a2e099c488f21c0193934b36533fc"
+    },
+    {
+      "backbone_state_sha256": "0df838819909faa38db698bd711529be3d2fd4b076859c46a4720cbe3fdc03f4",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EE/pt0/ft2/best.pt",
+        "sha256": "22d6e120e8f24fb5b0bb15bcb2d463733dea39d6599ed0234841cb9ff47f2ee1"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "3e996e0f448d66d72e033902f741bd68b53d1b53530d1a519643cdf4048de64e",
+      "id": "EE-pt0-ft2",
+      "job": {
+        "condition": "EE",
+        "ft_seed": 2,
+        "pt_seed": 0,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EE-pt0",
+        "sha256": "5af7730f436af372a0d43bfed57f87a3ea2e6aa4826493aa21eacd3acdd4dccc",
+        "state_sha256": "be2793719f6a9cbd4d15528e4c0295d8a1558eb7b0ecf098eceb00c2cee35ecd"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "d448ae3be2e175876403773442f1d22216182a6102697191e6c6dba022b3bef8",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "06d73f8a737c536e7d56416b0c20ddbb7b4cecd028a829828ec16e1c4b38ec30"
+    },
+    {
+      "backbone_state_sha256": "53a54e3b371a9e284333d75e587202d9ac6d611d6920b3cd24a324e5bf26160f",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EP/pt1/ft0/best.pt",
+        "sha256": "1a4e205e237b684cc14b79aea27a59ba45adb68e3e2ee0d345a7476433d88e3c"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "aa55d04a39b38d0029d3c241aed34f3a19d3661d5f44c1713b7f40969c78e311",
+      "id": "EP-pt1-ft0",
+      "job": {
+        "condition": "EP",
+        "ft_seed": 0,
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EP-pt1",
+        "sha256": "09c034afc616d6ed529fe62af1c604a07e0bc64a32f58630908300caf250c44a",
+        "state_sha256": "75b547c5e431c1d995755d054a0b7aad403c2aaa463eedb1bdd38c634b098159"
+      },
+      "selected_epoch": 1,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "18ea6da80c0554321a0c226b5776eb0bd9202943d316c380beb9292b6e0307d4",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "ee45255532196a6639d8b2a6d53146276e7866e4f1f3261ebe2053738704e27b"
+    },
+    {
+      "backbone_state_sha256": "38c35efc7c17e78d05b8ef2f427d8359275698fb9506413a156aa08373bbadb2",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EP/pt1/ft1/best.pt",
+        "sha256": "2e3ad2344834e5a70403bbef8c19f55aacb6b25b83725138bb82e2274723797c"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "e7ce95e30e08bd2d1e6d8edd20c526fa36bcced29dc49a5f68f911c1e00d9abb",
+      "id": "EP-pt1-ft1",
+      "job": {
+        "condition": "EP",
+        "ft_seed": 1,
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EP-pt1",
+        "sha256": "09c034afc616d6ed529fe62af1c604a07e0bc64a32f58630908300caf250c44a",
+        "state_sha256": "75b547c5e431c1d995755d054a0b7aad403c2aaa463eedb1bdd38c634b098159"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "13a2cfcdd361e229e179d3868c4818558657b9440196658269cba769267930c7",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "8310e8b4c2a20b0aae6d28c688b411c449064e7b02e78027c7e75126acbc5da3"
+    },
+    {
+      "backbone_state_sha256": "cafe4df0d4e922fc3eab0436527226edf072d2d4d1ade2398606ecfadc4e19d1",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EP/pt1/ft2/best.pt",
+        "sha256": "47615a93378959abbe6ffaf3475a6561ec9c6d11a94a04da6954b6801994704e"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "248c6b293dd9c6f4e88b2c9f6c3749f72c3d18ec48fdca4ca4b1c3ed4a403412",
+      "id": "EP-pt1-ft2",
+      "job": {
+        "condition": "EP",
+        "ft_seed": 2,
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EP-pt1",
+        "sha256": "09c034afc616d6ed529fe62af1c604a07e0bc64a32f58630908300caf250c44a",
+        "state_sha256": "75b547c5e431c1d995755d054a0b7aad403c2aaa463eedb1bdd38c634b098159"
+      },
+      "selected_epoch": 5,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "a3add110ff52792e7df7f540925b06da42649a418d48e01a6318c05dd90b7908",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "f6eaa338c9d649a440915a333a02d62800c39104180f628c12cfbb4d35d0783a"
+    },
+    {
+      "backbone_state_sha256": "fefb18acf164508f3291214deadc1a3433b09ac60a26c6bf18aafb604f4652f3",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/ES/pt1/ft0/best.pt",
+        "sha256": "b24e6de1f73186bc5167afce790c5794dd109f1d077fde1dc207ff4c360bed5c"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "ed7651fe8547a4a1bbf3acf883e9c2e8303b3573ac541ffc90c3ca3defe280d1",
+      "id": "ES-pt1-ft0",
+      "job": {
+        "condition": "ES",
+        "ft_seed": 0,
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "ES-pt1",
+        "sha256": "2f357c92c20c633a636f936246bfeadec31a9ee8792bfcaef1db2acf3ee1a737",
+        "state_sha256": "1da85f639f02e8a9a2fe41db83f7c951cef9a235466a340da3b4d94dfc2d8cfc"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "03adfbec615f0493463f5404db8b8510dae1487145caa2c0ff17f5ba7e0b9aba",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "ebc41837d2f6351175a71f3752ad20e57c18138691fef0764b90f9c61d218452"
+    },
+    {
+      "backbone_state_sha256": "7b46c42e1a21ea63275edba2629205b85bd57d597e098782a51063f9d0232cf3",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/ES/pt1/ft1/best.pt",
+        "sha256": "d43962d06f256000a8707dbc61e3d860dcebd4d50e0ac77b724ef921a79aae2c"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "4d7cf2502b9de435fd76220dce1c0025078c9108dc36a356a2e3ec5d96e6542a",
+      "id": "ES-pt1-ft1",
+      "job": {
+        "condition": "ES",
+        "ft_seed": 1,
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "ES-pt1",
+        "sha256": "2f357c92c20c633a636f936246bfeadec31a9ee8792bfcaef1db2acf3ee1a737",
+        "state_sha256": "1da85f639f02e8a9a2fe41db83f7c951cef9a235466a340da3b4d94dfc2d8cfc"
+      },
+      "selected_epoch": 2,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "8cdfde8b4ee968701fbf1db71b87156286a73e089f2677a7ccaef2ee4447393f",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "9e857c2113a1f624cf471b8263f3451dbf901542ef40daf23fe3f993206a3019"
+    },
+    {
+      "backbone_state_sha256": "f9efb8be122a08e79d844826d229563070163f258f562cd2bc63d2e7042bc79a",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/ES/pt1/ft2/best.pt",
+        "sha256": "fe879c8b4f45a84e08d728affc2c4cd6d28fb87b92cc8759b4ddc408f786d8f9"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "af479f9e002a231cf4ae8fa4fa01cbb79c4f8fedd7e3b59be63adce2fe93986d",
+      "id": "ES-pt1-ft2",
+      "job": {
+        "condition": "ES",
+        "ft_seed": 2,
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "ES-pt1",
+        "sha256": "2f357c92c20c633a636f936246bfeadec31a9ee8792bfcaef1db2acf3ee1a737",
+        "state_sha256": "1da85f639f02e8a9a2fe41db83f7c951cef9a235466a340da3b4d94dfc2d8cfc"
+      },
+      "selected_epoch": 5,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "6293d8e506c62ed852f97562dd1a445c27f2c2c44f7cd15f45daa44251605e74",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "2294494d91cc41a3070ebe400dd57fb3caabb978a56b6d86965be366877bd423"
+    },
+    {
+      "backbone_state_sha256": "892a245d1d3d72d90f85b5226eb83121fbb0dee80da1bf3207517274d1b245e0",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EE/pt1/ft0/best.pt",
+        "sha256": "7e75b5380df75393dae4a125df812f6500288955ab92a20ef610eb15eaff646f"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "cd55d0669416df9328d738f205a871fed93bace116f92be9b3e845dae373a271",
+      "id": "EE-pt1-ft0",
+      "job": {
+        "condition": "EE",
+        "ft_seed": 0,
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EE-pt1",
+        "sha256": "653a88903ee373e5b8933c71d386a64ca6840249f9a42cc2c992b0202f04739f",
+        "state_sha256": "2081069fd01c7c0d80bea6899bab92996f17480b375d625edb1e7095445ac622"
+      },
+      "selected_epoch": 1,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "dc6722503f1fc078719712395780f49ecd49d24af0b36705d58b71578c5a4280",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "aae2eeddf0405a3fdc434db9f1ceaec2d827bde17692efaf55a9d5ad22d8bab9"
+    },
+    {
+      "backbone_state_sha256": "8b5e303a3c8d47c5237768c54371a42fc86b3ed37bac215e94fc6ffb727388e6",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EE/pt1/ft1/best.pt",
+        "sha256": "c869b1c0c8cf4288485936795fbb8263b5af55bc39fa9df0513758c5cbfd5a87"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "8b4a07c619c5a583ea3a29c762262f1dd61cbf45b3c4f9638c5fbb13d390475d",
+      "id": "EE-pt1-ft1",
+      "job": {
+        "condition": "EE",
+        "ft_seed": 1,
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EE-pt1",
+        "sha256": "653a88903ee373e5b8933c71d386a64ca6840249f9a42cc2c992b0202f04739f",
+        "state_sha256": "2081069fd01c7c0d80bea6899bab92996f17480b375d625edb1e7095445ac622"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "0a29cb65c4b2279ac65c69d30fa48730fcf3c443bfb699f648a155df8869d38b",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "07432909d3ef0b1a24860ffcb100289e54f54c1c38a85afacf4bafb260aa8fee"
+    },
+    {
+      "backbone_state_sha256": "4a2c9dd0f700196201949d044b6749533a5057cdf627010c2bf255e4dda42132",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EE/pt1/ft2/best.pt",
+        "sha256": "0db9423ef969016260d1ddbbf700d5bbc71340b6847e0c8ecf5e4696fa2bb732"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "aa7e1329289dd57a8dec2a01220fad56337c3629ffdd1caf7f662f9c703f3c44",
+      "id": "EE-pt1-ft2",
+      "job": {
+        "condition": "EE",
+        "ft_seed": 2,
+        "pt_seed": 1,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EE-pt1",
+        "sha256": "653a88903ee373e5b8933c71d386a64ca6840249f9a42cc2c992b0202f04739f",
+        "state_sha256": "2081069fd01c7c0d80bea6899bab92996f17480b375d625edb1e7095445ac622"
+      },
+      "selected_epoch": 2,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "5c324f5ab182218ec35c3a7dd4df800e900836ce5e8195e999d05a1a627e1beb",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "09c04fbc107c9759bf755851015d493bd51e0c86f379eb5512aef77c0fcb79f2"
+    },
+    {
+      "backbone_state_sha256": "5cec49bff5231109310f7657e16aae77fed7ee053a23a3ea02e18210df0b8e71",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EP/pt2/ft0/best.pt",
+        "sha256": "7ecaeba8d20e8f65b78a11412817da9cdaf84127c03765c1fb95a44442f921f4"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "2540f121300980c92e16ea23a81233f991f176205f93aec2d3cb16e577e267ec",
+      "id": "EP-pt2-ft0",
+      "job": {
+        "condition": "EP",
+        "ft_seed": 0,
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EP-pt2",
+        "sha256": "a1285feb6eb6380bfedfe670a27e9f09b19163b33f76145cc008de0b1e223155",
+        "state_sha256": "76e0af261c311b5bd49ffe47e72e7065d4f2405f1213222bff12cb42817f3f87"
+      },
+      "selected_epoch": 1,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "277347056d1b01883f3904a44b5a5811a0a9d4885e4e099deb2dc0e443e1dda9",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "f5493458ecf9bcfd654f07d1382fde315aa8edeffa219ed5fcdeb59664f0148e"
+    },
+    {
+      "backbone_state_sha256": "34a5a3529c4519d6cc2ef55ca15a9c8f22fb5b0951951d868238e335b8251a5f",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EP/pt2/ft1/best.pt",
+        "sha256": "34c588c5e10d7ba6c6320cc59cf883ad47465cdcf9a07d540a45e55720e993eb"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "ece0a91d346641a5d5e035ea74f2d2bab123779aa23f5175297989f815c2e273",
+      "id": "EP-pt2-ft1",
+      "job": {
+        "condition": "EP",
+        "ft_seed": 1,
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EP-pt2",
+        "sha256": "a1285feb6eb6380bfedfe670a27e9f09b19163b33f76145cc008de0b1e223155",
+        "state_sha256": "76e0af261c311b5bd49ffe47e72e7065d4f2405f1213222bff12cb42817f3f87"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "923cb47e0b918ffa2c6c449089c6d678aa60b876961e0bb317f80760032e7e40",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "f989b0df62e72edde1f5e253a0636a0973a265ce00641c55ced221a6c439d46e"
+    },
+    {
+      "backbone_state_sha256": "42b7478758a5b5aadebc220632e2223f60f60030a91474c9f9d0fc9db8c08687",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EP/pt2/ft2/best.pt",
+        "sha256": "c1af8f442b9e13944e2bb5158900c2f1ca824af7583ebcb5a365d6b6317cdd3f"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "06928d7c19bf664d442b4a8c940e97685952d489b9afca318058fd50deb7611c",
+      "id": "EP-pt2-ft2",
+      "job": {
+        "condition": "EP",
+        "ft_seed": 2,
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EP-pt2",
+        "sha256": "a1285feb6eb6380bfedfe670a27e9f09b19163b33f76145cc008de0b1e223155",
+        "state_sha256": "76e0af261c311b5bd49ffe47e72e7065d4f2405f1213222bff12cb42817f3f87"
+      },
+      "selected_epoch": 2,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "ad2bbfa5c830e6c29c07c6925db5f34fe3d94ceb1eee89015a1193a02d659d37",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "51cbf2fe41459089fb5967d69a40e5314456943530617e18ae86974e6744f4a9"
+    },
+    {
+      "backbone_state_sha256": "1a6e6d138b3859bc7b04fa1cba932e0757fd9d24e6bce2f443a9de9abd35f0fc",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/ES/pt2/ft0/best.pt",
+        "sha256": "4e3193aba5334d7c1093a156b8dc72b3690ac3cce149373c7aa01958e2dceb73"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "b9e5f287d9078622ffc96b4a95195c379d9ea8cdf5d3148da06be519a4777272",
+      "id": "ES-pt2-ft0",
+      "job": {
+        "condition": "ES",
+        "ft_seed": 0,
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "ES-pt2",
+        "sha256": "e954373b086d2d3fe3b015440a185f4a146e01825007bc57cbcc609ed3d30254",
+        "state_sha256": "531f13ab25facf6a21f3a730dd3cbebc82d8f79aa24526fdde96f57dbd7097d9"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "1e42c68537988297c3ca34b739231b86e27c3531b10461d2d5cb8a7f293c39c4",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "de3f41dac006cece0480313f3dbcd05d1ace0b1bb85473cbe50ac99f0aecbf99"
+    },
+    {
+      "backbone_state_sha256": "ddf2792b06f5a24061c1a815ded8be91593ed167e813be80ee87b8daa5c5c440",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/ES/pt2/ft1/best.pt",
+        "sha256": "5509eb7ac7f77b3378874e9f5ceb2d51176ff1b175edaec8bd86449596335c48"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "b9620ddc3c45f58f7d49fb211744029068cc4f461f350aca25827c91cf00c1b7",
+      "id": "ES-pt2-ft1",
+      "job": {
+        "condition": "ES",
+        "ft_seed": 1,
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "ES-pt2",
+        "sha256": "e954373b086d2d3fe3b015440a185f4a146e01825007bc57cbcc609ed3d30254",
+        "state_sha256": "531f13ab25facf6a21f3a730dd3cbebc82d8f79aa24526fdde96f57dbd7097d9"
+      },
+      "selected_epoch": 2,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "572ab4979350470329ffa11a1588c3c8732071b90f0b59ae9d9fc56c3c2f40a5",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "f7634a33e3ef27f1744a77dcb02cb1e301b49978185a21f527aa6a95ce9511e5"
+    },
+    {
+      "backbone_state_sha256": "bda43b7b2920f13c9cbcdcfec2937cf57e3817deaf11a1dc22a83e217509d49f",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/ES/pt2/ft2/best.pt",
+        "sha256": "bbe4ea6d3953fb9c4e954952c7deb3cbbfde9ad102de1c797fcb35333e4e41e5"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "5307fc528cfce750104759418259f9708bc2187e3c62db0667249d403f7e637c",
+      "id": "ES-pt2-ft2",
+      "job": {
+        "condition": "ES",
+        "ft_seed": 2,
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "ES-pt2",
+        "sha256": "e954373b086d2d3fe3b015440a185f4a146e01825007bc57cbcc609ed3d30254",
+        "state_sha256": "531f13ab25facf6a21f3a730dd3cbebc82d8f79aa24526fdde96f57dbd7097d9"
+      },
+      "selected_epoch": 2,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "0a5566ddf15c0ede4cb0f426c65f306b500f1d06990ab8dd30594c45351f98fc",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "b766d4109670f9b379f9ccb9555dcdfb737b710aea733bad1b2108a66b50b353"
+    },
+    {
+      "backbone_state_sha256": "6bafb6cdbdbe0e7605f56fb89916075cd9fab07eac1f55878b33f21ad0f0deb1",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EE/pt2/ft0/best.pt",
+        "sha256": "92946799e5a378609b6dae042db4c263e53fd8123f101102a3e50b1c8a694b1a"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "042e8bd55fa3a70ee7322751e5aa6a9553c0c170740ade25656de18072cd92bd",
+      "id": "EE-pt2-ft0",
+      "job": {
+        "condition": "EE",
+        "ft_seed": 0,
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EE-pt2",
+        "sha256": "68e49c6af5cb3fa34b1820925cb1751055c38c25de8122b5ba19a40937ad0ba9",
+        "state_sha256": "7b2de62c97d190cced9341476a36d0d281805c6f163f908099e7b600582897ea"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "b1d17fffef0c2f464c5b085cced5319dabda23713f98c8ea3049743f4e0e62b8",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "c2da98507c582107c17e22bb2716d4521801514a2404e7f41062e0cf7c514dcc"
+    },
+    {
+      "backbone_state_sha256": "3ad28c6dcf2c4cd47057cc9c45c97e853b2986a0cee6ff8c12c4f0ef504ea3a5",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EE/pt2/ft1/best.pt",
+        "sha256": "3879fab3b33328347f852ac813bbc194be808526b4b97b1613292126b56f7751"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "065531cd87316409c14083b53d208ac1fd9743a805c472d0cd09bcd635acae70",
+      "id": "EE-pt2-ft1",
+      "job": {
+        "condition": "EE",
+        "ft_seed": 1,
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EE-pt2",
+        "sha256": "68e49c6af5cb3fa34b1820925cb1751055c38c25de8122b5ba19a40937ad0ba9",
+        "state_sha256": "7b2de62c97d190cced9341476a36d0d281805c6f163f908099e7b600582897ea"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "8b6d74f95cefdb63cf9d8d2634689152687797fc480bae1756c12c3447257792",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "3993f66eec458e2d47994a4f04d63694698aa9c605186c8b749d7cfda62f46f4"
+    },
+    {
+      "backbone_state_sha256": "7ba012459b15d25e49bfa6a31e83494f3d201a2abf4e736b2fedbef1ff76472e",
+      "checkpoint": {
+        "bytes": 440154440,
+        "path": "checkpoints/source/EE/pt2/ft2/best.pt",
+        "sha256": "c2fcac930e4a69d8138dc508ca4471f52be6ce76c8a90efd819b0780f73225b5"
+      },
+      "config_sha256": "3e9e1f209ac83fa7b67a3ed566d7266c61f7bd4e4100a66d329810b0a866a6b2",
+      "head_description": "two-logit bias-free linear score.weight (2 x 768)",
+      "head_state_sha256": "76a717c181c2186b0142b5e09329c5365fe7569a0652a486d38beba576a7f5b9",
+      "id": "EE-pt2-ft2",
+      "job": {
+        "condition": "EE",
+        "ft_seed": 2,
+        "pt_seed": 2,
+        "smoke": false
+      },
+      "kind": "source_classifier",
+      "pretraining_parent": {
+        "id": "EE-pt2",
+        "sha256": "68e49c6af5cb3fa34b1820925cb1751055c38c25de8122b5ba19a40937ad0ba9",
+        "state_sha256": "7b2de62c97d190cced9341476a36d0d281805c6f163f908099e7b600582897ea"
+      },
+      "selected_epoch": 4,
+      "selection": "minimum source validation CE; ties earlier epoch",
+      "state_sha256": "bc4ea0f5bb08aa2589a3e6ed714f2228522cc07189d89cc705a1abf562a489d2",
+      "state_tensor_count": 149,
+      "tokenizer_sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+      "training_result_sha256": "7d89dd8f1e7ef94c867f444024111e0f3f41ab8769ed5fd566b876de8d256940"
+    }
+  ],
+  "prepared_manifest_sha256": "2ea23ffd2793ed2142156f2942cc4bfb77767a0c3e87ba668a77c34a3a16c010",
+  "release_id": "bio2nl-2026-10-02-models-v1",
+  "schema_version": 1,
+  "source_assets_manifest_sha256": "c6341ac0e8a810fa807d46d45c9358e189290a37af5870136bfcbd504b1efdd5",
+  "source_selection_sha256": "48de918e0b4a2b12ac3021072f601e2b1caf61730c77097fa9bfbfc75e15fb4c",
+  "tokenizer": {
+    "bytes": 2122913,
+    "path": "tokenizer.json",
+    "sha256": "1bb8092348368961ca211cbf4d066a0e0ebf612b35b401b07ed173476088130b",
+    "special_tokens": [
+      "<|pad_v2|>",
+      "<|eos_v2|>",
+      "<|pair_v2|>",
+      "<|unk_v2|>"
+    ],
+    "training_recipe": "Shared byte-level BPE trained on 16 MiB English and 16 MiB protein training text; historical v2 tokenizer reused",
+    "vocab_size": 32000
+  },
+  "training_protocol_sha256": "60ce5e0518475fb0e4ba8a83d34d45fbe4c89e74e12fb984abbe41c8fd3eff24",
+  "weight_license_status": "unassigned; no license grant is inferred from code or training-data licenses"
+}

portable_core.py

@@ -0,0 +1,241 @@
+"""Portable GPT-2 models for the frozen joint-pretraining experiment.
+
+No workspace paths, legacy module imports, downloads or device initialization are
+performed at import time. Checkpoints are accepted only with independently trusted
+file, tensor-state, job and provenance identities. The caller supplies those
+identities from the verified archive; a hash read from the checkpoint itself is
+not an independent trust anchor.
+"""
+from __future__ import annotations
+
+from contextlib import nullcontext
+import hashlib
+import json
+from pathlib import Path
+import re
+from typing import Mapping
+
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+from transformers import GPT2Config, GPT2LMHeadModel, GPT2Model
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def _sha256(value, name):
+    require(isinstance(value, str) and re.fullmatch(r"[0-9a-f]{64}", value) is not None,
+            "Invalid " + name)
+    return value
+
+
+def state_digest(state):
+    """Exact legacy name/dtype/shape framing, including all tied aliases."""
+    digest = hashlib.sha256()
+    require(isinstance(state, Mapping) and bool(state), "Empty or invalid tensor state")
+    require(all(isinstance(name, str) and torch.is_tensor(value)
+                for name, value in state.items()), "Invalid tensor-state entry")
+    for name, tensor in sorted(state.items()):
+        value = tensor.detach().cpu().contiguous()
+        header = json.dumps([name, str(value.dtype), list(value.shape)], separators=(",", ":")).encode()
+        digest.update(len(header).to_bytes(8, "big"))
+        digest.update(header)
+        data = value.numpy().tobytes()
+        digest.update(len(data).to_bytes(8, "big"))
+        digest.update(data)
+    return digest.hexdigest()
+
+
+def snapshot_state(model):
+    """Copy finite FP32 tensors to CPU while retaining exact shared aliases."""
+    aliases, result = {}, {}
+    for name, tensor in model.state_dict().items():
+        require(tensor.dtype == torch.float32 and torch.isfinite(tensor).all().item(),
+                "Invalid/nonfinite FP32 state: " + name)
+        key = (tensor.data_ptr(), tuple(tensor.shape), tuple(tensor.stride()), str(tensor.dtype))
+        if key not in aliases:
+            aliases[key] = tensor.detach().cpu().clone().contiguous()
+        result[name] = aliases[key]
+    return result
+
+
+def _seed(seed):
+    require(type(seed) is int and seed >= 0, "Seed must be a nonnegative integer")
+    return seed
+
+
+def make_config(design):
+    """Construct the offline architecture described by the frozen protocol."""
+    pretraining, tokenizer = design["pretraining"], design["tokenizer"]
+    values = dict(pretraining["architecture"])
+    require(values.pop("model_type", "gpt2") == "gpt2", "Only GPT-2 is supported")
+    config = GPT2Config(**values, vocab_size=tokenizer["vocab_size"],
+                        n_positions=pretraining["context_length"], n_ctx=pretraining["context_length"],
+                        bos_token_id=tokenizer["eos_token_id"], eos_token_id=tokenizer["eos_token_id"],
+                        pad_token_id=tokenizer["pad_token_id"])
+    config._attn_implementation = "sdpa"
+    config.use_cache = False
+    return config
+
+
+def create_pretraining_model(design, seed):
+    """Create a fresh FP32 LM without consuming the caller's CPU/GPU RNG."""
+    with torch.random.fork_rng(devices=[]):
+        torch.random.default_generator.manual_seed(_seed(seed))
+        return GPT2LMHeadModel(make_config(design)).float()
+
+
+class TransferClassifier(nn.Module):
+    """Original backbone/score state names and mask-based final-token pooling."""
+
+    def __init__(self, backbone, head_seed):
+        super().__init__()
+        if isinstance(backbone, GPT2LMHeadModel):
+            backbone = backbone.transformer
+        if not isinstance(backbone, GPT2Model):
+            raise TypeError("Expected GPT2Model or GPT2LMHeadModel")
+        self.backbone = backbone
+        with torch.random.fork_rng(devices=[]):
+            torch.random.default_generator.manual_seed(_seed(head_seed))
+            self.score = nn.Linear(backbone.config.n_embd, 2, bias=False, device="cpu", dtype=torch.float32)
+            nn.init.normal_(self.score.weight, std=0.02)
+        reference = next(backbone.parameters())
+        self.score.to(device=reference.device, dtype=reference.dtype)
+
+    def forward(self, input_ids, attention_mask):
+        require(input_ids.ndim == 2 and input_ids.shape == attention_mask.shape,
+                "Input/mask dimensions differ")
+        require(input_ids.shape[0] > 0 and input_ids.shape[1] > 0 and
+                torch.all((attention_mask == 0) | (attention_mask == 1)).item() and
+                torch.all(attention_mask.sum(1) > 0).item(), "Invalid or empty attention mask")
+        hidden = self.backbone(input_ids=input_ids, attention_mask=attention_mask,
+                               use_cache=False, return_dict=True).last_hidden_state
+        positions = torch.arange(input_ids.shape[1], device=input_ids.device).expand_as(input_ids)
+        last = positions.masked_fill(attention_mask == 0, -1).amax(dim=1)
+        return self.score(hidden[torch.arange(input_ids.shape[0], device=input_ids.device), last])
+
+
+def create_classifier(lm, fine_tuning_seed):
+    """Reuse the complete LM backbone and initialize only the two-logit head."""
+    require(isinstance(lm, GPT2LMHeadModel), "SFT must start from a complete GPT-2 LM")
+    return TransferClassifier(lm, fine_tuning_seed).float()
+
+
+def load_checkpoint(path, *, expected_sha256, expected_kind, expected_job,
+                    expected_state_sha256, expected_protocol_sha256, expected_manifest_sha256,
+                    expected_epoch=None, expected_config=None):
+    """Safely load a trusted frozen checkpoint on CPU with exact provenance.
+
+    The file SHA is checked on the same open file handle used for weights-only
+    deserialization. There is deliberately no unsafe pickle fallback. Returned
+    models are in evaluation mode with gradients disabled; training from a new
+    initialization uses the constructors above.
+    """
+    for value, name in ((expected_sha256, "file SHA-256"),
+                        (expected_state_sha256, "state SHA-256"),
+                        (expected_protocol_sha256, "protocol SHA-256"),
+                        (expected_manifest_sha256, "manifest SHA-256")):
+        _sha256(value, name)
+    require(expected_kind in ("causal_lm", "source_classifier"), "Invalid expected checkpoint kind")
+    require(isinstance(expected_job, dict) and bool(expected_job), "Expected job identity is required")
+    require(expected_epoch is None or (type(expected_epoch) is int and expected_epoch > 0),
+            "Invalid expected epoch")
+    with Path(path).open("rb") as stream:
+        digest = hashlib.sha256()
+        for chunk in iter(lambda: stream.read(4 * 1024 * 1024), b""):
+            digest.update(chunk)
+        require(digest.hexdigest() == expected_sha256, "Checkpoint file SHA-256 differs")
+        stream.seek(0)
+        payload = torch.load(stream, map_location="cpu", weights_only=True)
+    require(isinstance(payload, dict) and type(payload.get("schema_version")) is int and
+            payload["schema_version"] == 1 and payload.get("kind") == expected_kind,
+            "Invalid checkpoint schema/kind")
+    metadata, config_values, state = payload.get("metadata"), payload.get("config"), payload.get("state_dict")
+    require(isinstance(metadata, dict) and isinstance(config_values, dict), "Invalid checkpoint metadata/config")
+    require(metadata.get("job") == expected_job, "Checkpoint job differs")
+    require(metadata.get("protocol_sha256") == expected_protocol_sha256, "Checkpoint protocol differs")
+    require(metadata.get("prepared_manifest_sha256") == expected_manifest_sha256, "Checkpoint manifest differs")
+    require(expected_epoch is None or metadata.get("epoch") == expected_epoch, "Checkpoint epoch differs")
+    require(payload.get("state_sha256") == expected_state_sha256, "Checkpoint declared state differs")
+    require(isinstance(state, Mapping) and bool(state) and
+            all(isinstance(name, str) and torch.is_tensor(value) and value.dtype == torch.float32
+                and torch.isfinite(value).all().item() for name, value in state.items()),
+            "Invalid/nonfinite FP32 checkpoint state")
+    require(state_digest(state) == expected_state_sha256, "Checkpoint tensor-state SHA-256 differs")
+    require(config_values.get("model_type", "gpt2") == "gpt2", "Invalid checkpoint architecture")
+    if expected_config is not None:
+        require(isinstance(expected_config, Mapping) and bool(expected_config), "Invalid expected config")
+        require(all(config_values.get(key) == value for key, value in expected_config.items()),
+                "Checkpoint config differs")
+    config = GPT2Config.from_dict(config_values)
+    config._attn_implementation = "sdpa"
+    config.use_cache = False
+    with torch.random.fork_rng(devices=[]):
+        if expected_kind == "causal_lm":
+            model = GPT2LMHeadModel(config)
+        else:
+            model = TransferClassifier(GPT2Model(config), 0)
+        model.load_state_dict(state, strict=True)
+    require(state_digest(model.state_dict()) == expected_state_sha256, "Reloaded model state differs")
+    model.float().eval().requires_grad_(False)
+    return model, payload
+
+
+def _as_numpy(value):
+    return value.detach().cpu().numpy() if torch.is_tensor(value) else np.asarray(value)
+
+
+def validate_arrays(arrays, config):
+    """Reject inconsistent encodings without silently changing any input row."""
+    require(isinstance(arrays, Mapping) and {"input_ids", "attention_mask", "labels"} <= arrays.keys(),
+            "Missing encoded arrays")
+    values = {name: _as_numpy(arrays[name]) for name in ("input_ids", "attention_mask", "labels")}
+    ids, mask, labels = (values[name] for name in ("input_ids", "attention_mask", "labels"))
+    require(all(value.dtype == np.int64 for value in values.values()), "Encoded arrays must be int64")
+    require(ids.ndim == 2 and ids.shape == mask.shape and labels.shape == (len(ids),) and
+            len(ids) > 0 and 0 < ids.shape[1] <= config.n_positions, "Invalid encoded array dimensions")
+    require(np.all((ids >= 0) & (ids < config.vocab_size)), "Token ID outside vocabulary")
+    require(np.all((mask == 0) | (mask == 1)) and np.all(mask.sum(1) > 0) and
+            np.all(np.diff(mask, axis=1) <= 0), "Expected nonempty right-padded binary masks")
+    require(np.all((labels == 0) | (labels == 1)), "Expected binary labels")
+    return values
+
+
+@torch.inference_mode()
+def predict_source(model, arrays, batch_size=32, device="cpu", precision="float32"):
+    """Fixed-head inference; label 1 direction and argmax ties to label 0."""
+    require(isinstance(model, TransferClassifier), "Expected a complete source classifier")
+    require(type(batch_size) is int and batch_size > 0, "Invalid batch size")
+    device = torch.device(device)
+    require((device.type == "cpu" and precision == "float32") or
+            (device.type == "cuda" and precision == "bfloat16"), "Explicit CPU FP32 or CUDA BF16 required")
+    if device.type == "cuda":
+        require(torch.cuda.is_available() and torch.cuda.is_bf16_supported(), "CUDA BF16 unavailable")
+        require(not torch.backends.cuda.matmul.allow_tf32 and not torch.backends.cudnn.allow_tf32,
+                "TF32 must be disabled for fixed scoring")
+        if device.index is None:
+            device = torch.device("cuda", torch.cuda.current_device())
+    require(all(parameter.device == device and parameter.dtype == torch.float32
+                for parameter in model.parameters()), "Model must already be FP32 on the explicit device")
+    values = validate_arrays(arrays, model.backbone.config)
+    model.eval()
+    chunks = []
+    for start in range(0, len(values["labels"]), batch_size):
+        stop = min(start + batch_size, len(values["labels"]))
+        batch_mask = values["attention_mask"][start:stop]
+        maximum = int(batch_mask.sum(1).max())
+        width = min(batch_mask.shape[1], ((maximum + 7) // 8) * 8)
+        ids = torch.as_tensor(values["input_ids"][start:stop, :width], device=device)
+        mask = torch.as_tensor(batch_mask[:, :width], device=device)
+        context = torch.autocast("cuda", dtype=torch.bfloat16) if device.type == "cuda" else nullcontext()
+        with context:
+            logits = model(ids, mask)
+        logp = F.log_softmax(logits.float(), dim=-1)
+        require(torch.isfinite(logp).all().item(), "Nonfinite source predictions")
+        chunks.append(logp.cpu().numpy().astype(np.float64))
+    logp = np.concatenate(chunks)
+    return {"labels": values["labels"].copy(), "log_probabilities": logp, "predictions": logp.argmax(1)}

requirements-inference.txt

@@ -0,0 +1,4 @@
+numpy==2.2.6
+torch==2.3.0
+transformers==4.45.2
+tokenizers==0.20.0

test_audit.json

@@ -0,0 +1,12 @@
+{
+  "code_sha256": {
+    "inference.py": "43f5a1c770354b588b046ff02e4d03df4c13086224df4fba1285f8f2b3cf91ec",
+    "portable_core.py": "b2362edf8850fe20fbd23cc958a71f92ac2a187de4316f53f8750d3bca857592",
+    "test_inference.py": "26a8dd9c94fee295a7ba20ae65da922975f6ee1a66ad9f500fea16c8ad63f3d8"
+  },
+  "completed_at_utc": "2026-10-03T08:22:52.059505+00:00",
+  "errors": 0,
+  "failures": 0,
+  "status": "passed",
+  "tests_run": 17
+}

test_inference.py

@@ -0,0 +1,159 @@
+"""Integrity/adversarial tests; no large models, GPU or training required."""
+import copy
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+import numpy as np
+import torch
+from transformers import GPT2Config, GPT2Model
+
+import inference as api
+import portable_core as core
+
+
+HERE = Path(__file__).resolve().parent
+
+
+class IntegrityTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        torch.set_num_threads(2)
+
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.root = Path(self.temp.name)
+        cfg = GPT2Config(vocab_size=37, n_positions=32, n_ctx=32, n_embd=16, n_layer=1, n_head=2,
+                         n_inner=32, eos_token_id=1, pad_token_id=0)
+        cfg._attn_implementation = "sdpa"
+        model = core.TransferClassifier(GPT2Model(cfg), 0)
+        self.payload = {"schema_version": 1, "kind": "source_classifier", "config": cfg.to_dict(),
+                        "metadata": {"job": {"condition": "EP", "pt_seed": 0, "ft_seed": 0, "smoke": False},
+                                     "protocol_sha256": "a" * 64, "prepared_manifest_sha256": "b" * 64, "epoch": 2},
+                        "state_dict": core.snapshot_state(model)}
+        self.path = self.root / "toy.pt"
+        self.save()
+
+    def tearDown(self):
+        self.temp.cleanup()
+
+    def save(self):
+        self.payload["state_sha256"] = core.state_digest(self.payload["state_dict"])
+        torch.save(self.payload, self.path)
+        self.kw = dict(expected_sha256=api.file_sha(self.path), expected_kind="source_classifier",
+            expected_job=self.payload["metadata"]["job"], expected_state_sha256=self.payload["state_sha256"],
+            expected_protocol_sha256="a" * 64, expected_manifest_sha256="b" * 64, expected_epoch=2,
+            expected_config=self.payload["config"])
+
+    def test_intact_reloads(self):
+        model, payload = core.load_checkpoint(self.path, **self.kw)
+        self.assertEqual(core.state_digest(model.state_dict()), payload["state_sha256"])
+        self.assertFalse(model.training)
+        self.assertTrue(all(not x.requires_grad for x in model.parameters()))
+
+    def test_corrupt_file_rejected(self):
+        with self.path.open("ab") as stream:
+            stream.write(b"tampered")
+        with self.assertRaisesRegex(ValueError, "file SHA"):
+            core.load_checkpoint(self.path, **self.kw)
+
+    def test_missing_head_rejected_even_with_new_digest(self):
+        del self.payload["state_dict"]["score.weight"]
+        self.save()
+        with self.assertRaises(RuntimeError):
+            core.load_checkpoint(self.path, **self.kw)
+
+    def test_wrong_head_shape_rejected_even_with_new_digest(self):
+        self.payload["state_dict"]["score.weight"] = torch.zeros(3, 16)
+        self.save()
+        with self.assertRaises(RuntimeError):
+            core.load_checkpoint(self.path, **self.kw)
+
+    def test_provenance_rejected(self):
+        for key in ("expected_protocol_sha256", "expected_manifest_sha256", "expected_state_sha256"):
+            changed = dict(self.kw, **{key: "c" * 64})
+            with self.assertRaises(ValueError):
+                core.load_checkpoint(self.path, **changed)
+
+    def test_wrong_job_rejected(self):
+        changed = dict(self.kw, expected_job={**self.kw["expected_job"], "ft_seed": 1})
+        with self.assertRaisesRegex(ValueError, "job differs"):
+            core.load_checkpoint(self.path, **changed)
+
+    def test_wrong_epoch_rejected(self):
+        with self.assertRaisesRegex(ValueError, "epoch differs"):
+            core.load_checkpoint(self.path, **{**self.kw, "expected_epoch": 1})
+
+    def test_wrong_config_rejected(self):
+        with self.assertRaisesRegex(ValueError, "config differs"):
+            core.load_checkpoint(self.path, **{**self.kw, "expected_config": {"n_embd": 32}})
+
+    def test_json_config_label_keys_roundtrip(self):
+        public_config = json.loads(json.dumps(self.payload["config"]))
+        digest = api.canonical_sha(public_config)
+        expected = api.config_for_core(public_config)
+        model, payload = core.load_checkpoint(self.path, **{**self.kw, "expected_config": expected})
+        self.assertEqual(api.original_config_sha_after_load(payload["config"]), digest)
+        self.assertEqual(api.canonical_sha(public_config), digest)
+
+    def test_unexpected_config_runtime_value_rejected(self):
+        changed = {**self.payload["config"], "attn_implementation": "eager"}
+        with self.assertRaisesRegex(ValueError, "injected attention"):
+            api.original_config_sha_after_load(changed)
+
+    def test_nonfinite_rejected(self):
+        self.payload["state_dict"]["score.weight"][0, 0] = float("nan")
+        self.save()
+        with self.assertRaisesRegex(ValueError, "nonfinite"):
+            core.load_checkpoint(self.path, **self.kw)
+
+    def test_path_escape_and_ambiguity_rejected(self):
+        for relative in ("../secret", "/tmp/file", "a/../b", "a//b", "./a", "a\\b"):
+            with self.assertRaises(ValueError):
+                api.safe_path(self.root, relative)
+
+    def test_catalog_file_tamper(self):
+        path = HERE / "model_catalog.json"
+        original = path.read_bytes()
+        bad = self.root / "catalog.json"
+        bad.write_bytes(original + b" ")
+        with self.assertRaisesRegex(ValueError, "Catalog SHA"):
+            api.read_catalog(bad, api.file_sha(path))
+
+    def test_wrong_parent_rejected_with_rehashed_catalog(self):
+        data = json.loads((HERE / "model_catalog.json").read_text())
+        entry = next(x for x in data["models"] if x["kind"] == "source_classifier")
+        entry["pretraining_parent"]["id"] = "ES-pt0"
+        path = self.root / "catalog.json"
+        path.write_text(json.dumps(data))
+        with self.assertRaisesRegex(ValueError, "parent provenance"):
+            api.read_catalog(path, api.file_sha(path))
+
+    def test_tokenizer_hash_tamper(self):
+        catalog = json.loads((HERE / "model_catalog.json").read_text())
+        raw = (HERE / "tokenizer.json").read_bytes()
+        (self.root / "tokenizer.json").write_bytes(raw.replace(b"BPE", b"XYZ", 1))
+        with self.assertRaisesRegex(ValueError, "SHA"):
+            api.load_tokenizer(catalog, self.root)
+
+    def test_encoding_caps_and_roundtrip(self):
+        catalog = json.loads((HERE / "model_catalog.json").read_text())
+        tokenizer = api.load_tokenizer(catalog, HERE)
+        pair = {"sentence1": "hello world " * 400, "sentence2": "protein " * 400}
+        arrays, info = api.encode_pairs(tokenizer, [pair])
+        a = tokenizer.encode(pair["sentence1"], add_special_tokens=False).ids[:255]
+        b = tokenizer.encode(pair["sentence2"], add_special_tokens=False).ids[:255]
+        self.assertEqual(arrays["input_ids"][0].tolist(), a + [2] + b + [1])
+        self.assertTrue(arrays["attention_mask"].all())
+        self.assertEqual(info[0]["truncated_endpoints"], [True, True])
+
+    def test_labels_or_empty_endpoints_rejected(self):
+        tokenizer = api.load_tokenizer(json.loads((HERE / "model_catalog.json").read_text()), HERE)
+        for pair in ({"sentence1": "a", "sentence2": "b", "label": 1}, {"sentence1": "", "sentence2": "b"}):
+            with self.assertRaises(ValueError):
+                api.encode_pairs(tokenizer, [pair])
+
+
+if __name__ == "__main__":
+    unittest.main()

test_output.txt

@@ -0,0 +1,22 @@
+test_catalog_file_tamper (test_inference.IntegrityTests.test_catalog_file_tamper) ... ok
+test_corrupt_file_rejected (test_inference.IntegrityTests.test_corrupt_file_rejected) ... ok
+test_encoding_caps_and_roundtrip (test_inference.IntegrityTests.test_encoding_caps_and_roundtrip) ... ok
+test_intact_reloads (test_inference.IntegrityTests.test_intact_reloads) ... ok
+test_json_config_label_keys_roundtrip (test_inference.IntegrityTests.test_json_config_label_keys_roundtrip) ... ok
+test_labels_or_empty_endpoints_rejected (test_inference.IntegrityTests.test_labels_or_empty_endpoints_rejected) ... ok
+test_missing_head_rejected_even_with_new_digest (test_inference.IntegrityTests.test_missing_head_rejected_even_with_new_digest) ... ok
+test_nonfinite_rejected (test_inference.IntegrityTests.test_nonfinite_rejected) ... ok
+test_path_escape_and_ambiguity_rejected (test_inference.IntegrityTests.test_path_escape_and_ambiguity_rejected) ... ok
+test_provenance_rejected (test_inference.IntegrityTests.test_provenance_rejected) ... ok
+test_tokenizer_hash_tamper (test_inference.IntegrityTests.test_tokenizer_hash_tamper) ... ok
+test_unexpected_config_runtime_value_rejected (test_inference.IntegrityTests.test_unexpected_config_runtime_value_rejected) ... ok
+test_wrong_config_rejected (test_inference.IntegrityTests.test_wrong_config_rejected) ... ok
+test_wrong_epoch_rejected (test_inference.IntegrityTests.test_wrong_epoch_rejected) ... ok
+test_wrong_head_shape_rejected_even_with_new_digest (test_inference.IntegrityTests.test_wrong_head_shape_rejected_even_with_new_digest) ... ok
+test_wrong_job_rejected (test_inference.IntegrityTests.test_wrong_job_rejected) ... ok
+test_wrong_parent_rejected_with_rehashed_catalog (test_inference.IntegrityTests.test_wrong_parent_rejected_with_rehashed_catalog) ... ok
+
+----------------------------------------------------------------------
+Ran 17 tests in 0.361s
+
+OK