Stoicheia: training and evaluation code

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+logs/
+out/
+.venv-cpu/
+.venv-x86/
+*.egg-info/
+build/
+dist/
+hf_release_output/

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing
+      the origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MODEL_CARDS_INDEX.md

@@ -0,0 +1,44 @@
+# Stoicheia — Released Models and Datasets
+
+All models are character-level masked-diffusion Transformers for Ancient Greek (405M
+params, `d_model=1024`, depth 32), loadable via
+`AutoModel.from_pretrained(repo_id, trust_remote_code=True)`. See each model card for
+usage examples specific to that checkpoint's task.
+
+## Pretrained backbones (11)
+
+Ten rotated, work-level-decontaminated literary folds plus one documentary-clean model.
+For any passage in the open training corpus, at least one of these eleven has provably
+never seen it during pretraining.
+
+| model | decontamination |
+|---|---|
+| [`Ericu950/Stoicheia-doc_clean`](https://huggingface.co/Ericu950/Stoicheia-doc_clean) | zero documentary (inscription/papyrus) exposure of any kind |
+| [`Ericu950/Stoicheia-fold-0`](https://huggingface.co/Ericu950/Stoicheia-fold-0) … [`fold-9`](https://huggingface.co/Ericu950/Stoicheia-fold-9) | rotated 80/10/10 literary split, fold *k*'s test set unseen by fold *k*'s model |
+
+## Fine-tuned downstream models (4)
+
+All built on `Stoicheia-doc_clean`.
+
+| model | task |
+|---|---|
+| [`Ericu950/Stoicheia-restoration-test0`](https://huggingface.co/Ericu950/Stoicheia-restoration-test0) … [`-test9`](https://huggingface.co/Ericu950/Stoicheia-restoration-test9) | documentary restoration, ten checkpoints — checkpoint *k* holds out every PHI/TM identifier ending in digit *k*, so every document in the corpus has a model that provably never saw it |
+| [`Ericu950/Stoicheia-tagger-parser`](https://huggingface.co/Ericu950/Stoicheia-tagger-parser) | morphosyntactic tagging (XPOS/UPOS/lemma) + dependency parsing |
+| [`Ericu950/Stoicheia-meter`](https://huggingface.co/Ericu950/Stoicheia-meter) | macronization (vowel length) + metrical scansion, trained jointly |
+| [`Ericu950/Stoicheia-macronizer`](https://huggingface.co/Ericu950/Stoicheia-macronizer) | macronization only — the arm the paper's macronization ablation is measured on |
+
+Not released as a model: the authorship-attribution / hermeneutic probes, which are
+designed to be fine-tuned per-task rather than distributed as a general-purpose model
+(see the paper's Discussion section).
+
+## Datasets
+
+| dataset | what it is |
+|---|---|
+| [`Ericu950/AncientGreek`](https://huggingface.co/datasets/Ericu950/AncientGreek) | main pretraining corpus (gold + silver tiers) |
+| [`Ericu950/SyntheticAncientGreek-CorpusCorporum`](https://huggingface.co/datasets/Ericu950/SyntheticAncientGreek-CorpusCorporum) | bronze synthetic augmentation tier |
+| [`Ericu950/Inscriptions_2`](https://huggingface.co/datasets/Ericu950/Inscriptions_2) | PHI inscriptions used for the 10-fold split and restoration fine-tuning |
+
+Not re-released (already public elsewhere, cited not duplicated): the *Norma*
+macronization/scansion benchmark (GitHub), the OGA/AGDT treebank
+(Celano's own repository).

NOTICE

@@ -0,0 +1,21 @@
+Stoicheia
+Copyright 2026 Anonymous (under review)
+
+This product is licensed under the Apache License, Version 2.0 (see LICENSE).
+
+Evaluation of the Ithaca and Aeneas baselines uses DeepMind's released code, obtained
+separately from their repositories (not vendored here): the Ithaca codebase
+from DeepMind:
+
+    Ithaca
+    Copyright DeepMind Technologies Limited
+    https://github.com/google-deepmind/ithaca
+    Licensed under the Apache License, Version 2.0
+
+Ithaca (Assael, Sommerschield, Shillingford, Bordbar, Pavlopoulos, Chatzipanagiotou,
+Androutsopoulos, Prag & de Freitas, "Restoring and attributing ancient texts using deep
+neural networks", Nature 2022) is used purely as a reference baseline that this project's
+own inscription-restoration evaluation code (`insc/eval/`) compares against. No code from
+Ithaca has been copied into this repository's source tree; the baseline harness expects a
+separately downloaded checkout (see `scripts/slurm/insc_ithaca_gpu.sbatch`), which retains
+its own LICENSE.

README.md

@@ -0,0 +1,98 @@
+# Stoicheia
+
+A character-level masked-diffusion Transformer for Ancient Greek, pretrained on an
+open, revision-pinned corpus and released as eleven decontaminated checkpoints (ten
+rotated literary folds + one documentary-clean model), fine-tuned for restoration of
+damaged inscriptions/papyri, morphosyntactic tagging and dependency parsing, and
+macronization/metrical scansion.
+
+This repository is the training/evaluation code. The pretrained and fine-tuned model
+weights are on the HuggingFace Hub — see [`MODEL_CARDS_INDEX.md`](MODEL_CARDS_INDEX.md)
+for the full list, or jump straight to
+[`Ericu950/Stoicheia-doc_clean`](https://huggingface.co/Ericu950/Stoicheia-doc_clean)
+(the flagship backbone) or
+[`Ericu950/Stoicheia-restoration-test3`](https://huggingface.co/Ericu950/Stoicheia-restoration-test3) (or any of the ten digit-rotation checkpoints) /
+[`-tagger-parser`](https://huggingface.co/Ericu950/Stoicheia-tagger-parser) for a
+ready-to-use downstream model (or [`-meter`](https://huggingface.co/Ericu950/Stoicheia-meter) for
+macronization and scansion). All model repos are public: weights ship as `model.safetensors` with a `config.json`,
+loadable directly through `AutoModel.from_pretrained(..., trust_remote_code=True)`.
+
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Ericu950/stoicheia/blob/main/Stoicheia_demo.ipynb)
+
+Run everything in the browser: [`Stoicheia_demo.ipynb`](Stoicheia_demo.ipynb) restores a lacuna of
+unknown width, picks the checkpoint that has provably never read your document, tags and parses a
+verse of Homer, macronizes and scans a line, and scores the macronizer on the benchmark.
+
+## Quickstart (no training required)
+
+```python
+import torch
+from transformers import AutoModel
+from huggingface_hub import hf_hub_download
+
+REPO = "Ericu950/Stoicheia-doc_clean"
+model = AutoModel.from_pretrained(REPO, trust_remote_code=True).eval()
+
+# `trust_remote_code` loads the model classes; the processor is a separate helper, so
+# fetch it into the working directory before importing it.
+hf_hub_download(repo_id=REPO, filename="processing_char_bert.py", local_dir=".")
+from processing_char_bert import CharBertProcessor
+
+processor = CharBertProcessor()
+
+# a lacuna of UNCERTAIN width, in text that's ALSO fully bare scriptio continua (no
+# spaces, no accents) -- the realistic case for damaged, unaccented primary sources.
+# Write "[N±M]" for a best-guess width N and a plausible range N-M..N+M; every
+# candidate width is scored by the model's own confidence, recovering both the
+# width and the text while jointly restoring accents/word-boundaries throughout.
+text = "εναρχηηνο[5±3]καιολογοςηνπροστονθεον"
+best_text, best_width, candidates = processor.restore_elastic(model, text, mask_dia_boundary=True)
+print(best_text)  # -> ἐν ἀρχῇ ἦν ὁ λόγος, καὶ ὁ λόγος ἦν πρὸς τὸν θεόν.
+```
+
+A damaged inscription, unaccented and unspaced where the break falls:
+
+```python
+print(processor.restore_respaced(model, "ἔδοξεν τηβου-- καὶ τῷ δήμῳ"))
+# -> ἔδοξεν τῇ βουλῇ καὶ τῷ δήμῳ
+```
+
+Accents and word division are predictions, not requirements: a bare majuscule transcript is as
+readable to this model as a modern critical text, and the gap is filled in the same pass that
+decides where the words end.
+
+
+## What's here
+
+- `model/`, `data/`, `train/`, `eval/` — the pretraining architecture (`CharBertEncoder`,
+  a five-plane character-level masked-diffusion Transformer) and training loop.
+- `insc/` — restoration fine-tuning (inscriptions + papyri) and strict-protocol
+  evaluation (same-harness comparison against DeepMind's Ithaca).
+- `tagger/`, `parser/` — morphosyntactic tagging (factored XPOS, edit-script lemma,
+  UPOS) and biaffine dependency parsing, plus a joint multi-task model and a
+  pluggable HuggingFace-encoder bridge for cross-encoder ablations.
+- `meter/` — macronization (vowel length) and metrical scansion, including the
+  *Norma* benchmark protocol and rule-based silver-data mining pipeline.
+- `tests/` — CPU-only pytest suite.
+
+See [`REPRODUCING.md`](REPRODUCING.md) for the full environment setup and end-to-end
+reproduction walkthrough.
+
+## Citation
+
+```bibtex
+@misc{stoicheia2026,
+  title  = {Stoicheia: Character-Level Masked Diffusion for Ancient Greek Textual
+            Restoration, Parsing, and Metrical Scansion},
+  author = {Anonymous},
+  year   = {2026},
+  note   = {Under review; citation to be finalized on publication}
+}
+```
+
+## License
+
+Apache 2.0 (see `LICENSE`). External baselines (DeepMind's Ithaca and predictingthepast releases) are
+downloaded separately from their own repositories and retain their own licenses — see
+`NOTICE` and `REPRODUCING.md`.

REPRODUCING.md

@@ -0,0 +1,214 @@
+# Reproducing Stoicheia
+
+## 1. Environment
+
+```bash
+git clone https://github.com/Ericu950/stoicheia
+cd stoicheia
+export STOICHEIA_DATA=/path/to/a/writable/data+checkpoints/directory
+source env.sh
+pip install -e .
+```
+
+For GPU training at scale, the project used an Apptainer container on aarch64 GH200
+nodes via a SLURM cluster; the container image itself is not included in this repo (see
+`scripts/slurm/README.md` for what's expected inside it, and how to point `STOICHEIA_SIF`
+at your own equivalent, or run without a container at all). See the same file for the
+cluster-specific sbatch templates (edit the account/partition placeholders before
+submitting). For CPU-only work (tests, small-scale inference, data preparation),
+`pip install -r requirements-cpu.txt` is sufficient — no container needed,
+`attn_impl="sdpa"` runs on CPU.
+
+## 2. Data
+
+Three core datasets are already public and used as-is (no re-release needed):
+
+```python
+from datasets import load_dataset
+gold_silver = load_dataset("Ericu950/AncientGreek")                         # pretraining corpus
+bronze = load_dataset("Ericu950/SyntheticAncientGreek-CorpusCorporum")      # synthetic augmentation
+inscriptions = load_dataset("Ericu950/Inscriptions_2")                     # PHI inscriptions
+```
+
+Two further data dependencies are external, citable resources — clone/download them
+directly rather than expecting a copy in this repo:
+- **OGA/AGDT treebank** (tagging/parsing fine-tuning, morphosyntax evaluation): clone
+  Celano's own repository, `git.informatik.uni-leipzig.de/celano/morphosyntactic_parser_for_oga`.
+- **Norma** (macronization/scansion benchmark): released with the vowel-length paper
+  cited in the paper's macronization section; the harnesses read it through
+  `MACRONIZER_SRC` (see the last section of this file).
+
+The 10-fold decontamination split is built by the pipeline in `data/split_pipeline/`
+(MinHash-LSH near-duplicate clustering, a last-digit rule for papyri/inscriptions,
+and n-gram decontamination against the eval sets — see the last section of this file
+and `data/fold_manifests/SPLIT_DESIGN.md`). Its downstream consumer,
+`data/build_fold_shards.py`, takes a fold's `train.jsonl.zst` and builds the memmap
+shards the pretraining loader reads. In practice you don't need to rebuild the fold
+assignments from scratch: use the pretrained checkpoints directly
+(`MODEL_CARDS_INDEX.md`), and `data/fold_manifests/` records every fold's test-work
+assignments for verification.
+
+## 3. Pretraining (the 11 backbones)
+
+```bash
+sbatch scripts/slurm/pretrain_fold.sbatch 0     # one of ten literary folds (0-9)
+sbatch scripts/slurm/pretrain_doc_clean.sbatch  # the documentary-clean model
+```
+
+Each is a long-running, checkpointed, resumable job chain (dev-driven schedule, not
+step-capped — see the paper's Model section for the staged-anneal training regime).
+Pretrained checkpoints are also available directly on the Hub (see
+`MODEL_CARDS_INDEX.md`) — you do not need to re-pretrain to use or fine-tune the models.
+
+## 4. Fine-tuning the three downstream tasks
+
+All three fine-tune from `$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt` (or the equivalent
+Hub checkpoint, downloaded locally first if you want to fine-tune outside this
+pipeline's own checkpoint format).
+
+```bash
+# restoration, v2 recipe, held-out digit 3 (the paper's headline model)
+sbatch scripts/slurm/insc_finetune_whole_4node.sbatch configs/insc/finetune_whole_v4_t3v4.json
+
+# joint tagger + dependency parser
+sbatch scripts/slurm/syntax_joint_ddp.sbatch configs/syntax/joint_docclean_f3_s0.json
+
+# macronization + metrical scansion (joint), and the macron-only arm of the ablation
+sbatch scripts/slurm/meter_meter.sbatch configs/meter/joint_docclean.json
+sbatch scripts/slurm/meter_meter.sbatch configs/meter/mac_v2.json
+```
+
+For the leak-proof 10-fold restoration rotation used to interrogate individual
+inscriptions/papyri (every document gets a fine-tuned model that provably never saw it,
+regardless of which digit its ID ends in — restoration fine-tunes in about an hour, so
+the full rotation is cheap):
+
+```bash
+# test_digit/val_digit rotate together: (1,2), (2,3), ..., (9,0), (0,1)
+sbatch scripts/slurm/insc_finetune_whole_4node.sbatch configs/insc/finetune_whole_v4_t1v2.json
+```
+
+Each `configs/insc/finetune_whole_v*_t*v*.json` pins its own `test_digit`/
+`val_digit` fields; `insc/train/finetune_whole.py` reads them and exports
+`INSC_TEST_DIGIT`/`INSC_VAL_DIGIT` itself before any data loads, so the intended split
+holds however the script is launched. The eval scripts
+(`insc/eval/restore_strict{,_papyri}.py`) are not config-driven — when evaluating one of
+these fold models, export the matching `INSC_TEST_DIGIT`/`INSC_VAL_DIGIT` yourself
+before `--make-samples`/`--ckpt` (defaults to the flagship 3/4 split otherwise).
+
+## 5. Evaluation (reproducing the paper's tables)
+
+Every reconstruction number uses one protocol: whole documents, real lacunae left in
+context as unknowns, spaces counted toward the gap length, word division predicted, beam
+20, Levenshtein CER. `--make-samples` writes a frozen sample file; evaluation then reads
+it, so every system sees identical gaps.
+
+**Ten-fold rotation (Table 1).** For each held-out digit `t` (val digit `v = (t+1) % 10`),
+with the arm's checkpoint from `MODEL_CARDS_INDEX.md`:
+
+```bash
+export INSC_TEST_DIGIT=3 INSC_VAL_DIGIT=4          # must match the model's fold
+python -m insc.eval.restore_strict         --make-samples --n 100 --samples f3_inscr.json
+python -m insc.eval.restore_strict_papyri  --make-samples --n 100 --samples f3_pap.json
+python -m insc.eval.restore_strict        --ckpt <run>/best.pt --samples f3_inscr.json --out v2_d3_inscr.json
+python -m insc.eval.restore_strict_papyri --ckpt <run>/best.pt --samples f3_pap.json   --out v2_d3_pap.json
+```
+
+Repeat over the ten `v4_*` runs (paper revision v2), the ten `v3_*` runs (v1), and the ten
+`v3_randinit_*` runs (the matched control), then aggregate and run the fold-paired
+permutation tests with `python -m analysis.sig_all`.
+
+**Starting from a released checkpoint.** The Hub ships `model.safetensors` for
+`AutoModel.from_pretrained`, while the evaluation scripts read the trainer's `.pt`. Convert once:
+
+```bash
+python scripts/hf_to_eval_checkpoint.py \
+    --repo Ericu950/Stoicheia-restoration-test3 --out runs/t3v4/best.pt
+```
+
+The result is bit-identical to the checkpoint the paper evaluated (268 tensors, max absolute
+difference 0.0). Export `INSC_TEST_DIGIT`/`INSC_VAL_DIGIT` to match the checkpoint's held-out
+digit before running any evaluation below.
+
+**Head-to-head against Ithaca and Aeneas (Table 2).** All three systems read the frozen
+3,000-sample digit-3 file shipped in `insc/eval/frozen/`:
+
+```bash
+python -m insc.eval.restore_strict --ckpt <digit-3 run>/best.pt \
+    --samples insc/eval/frozen/strict_test_fold3_samples.json --out ours_strict.json
+python -m insc.eval.ithaca_baseline --samples insc/eval/frozen/strict_test_fold3_samples.json --out ithaca.json
+python -m insc.eval.ptp_baseline    --ckpt <aeneas>.pkl \
+    --samples insc/eval/frozen/strict_test_fold3_samples.json --out aeneas.json
+```
+
+**Recently edited documents (Tables 3-4).** Scored on the comparison release's own
+documents and normalization, with every system rescored under the same Levenshtein CER:
+
+```bash
+python -m insc.eval.restore_dsh --ckpt <run>/best.pt --data <recent-inscriptions>.jsonl --out ours_recent.json
+python -m insc.eval.ptp_baseline --ckpt <aeneas>.pkl --dsh <recent-inscriptions>.jsonl --out aeneas_recent.json
+python -m analysis.merge_dsh          # aggregate shards, macro over gap lengths
+```
+
+**Tagging and parsing (Table 5).** The full 5-fold x 2-seed matrix per encoder:
+
+```bash
+for f in 0 1 2 3 4; do for s in 0 1; do
+  sbatch scripts/slurm/syntax_joint_ddp.sbatch configs/syntax/joint_docclean_f${f}_s${s}.json
+done; done
+python -m parser.joint_evaluate --run $STOICHEIA_DATA/parser_data/runs/joint_docclean_f0_s0 --split test
+```
+
+**Macronization and scansion (Tables 6-7).** The macronization ablation uses the
+macron-only runs (`mac_v2*`, six seeds per arm), the scansion ablation the joint runs
+(`joint_docclean*` / `joint_randinit*`); the external macronizer comparison scores the
+joint model on Norma's 1,916 test positions:
+
+```bash
+python -m meter.predict --model $STOICHEIA_DATA/runs/meter_joint_docclean/best.pt --norma
+python -m meter.predict --model $STOICHEIA_DATA/runs/meter_mac_v2/best.pt --norma --norma-source git
+```
+
+`python -m analysis.paper_tables` collects finished evaluation logs into the table
+layouts used in the paper.
+
+## 6. Tests
+
+```bash
+pytest tests/ -q
+```
+CPU-only, seconds-scale. Covers normalization/packing/noising (pretraining), edit-script
+lemma encoding + dataset construction (tagger), macron/scansion mark parsing (meter),
+plus lightweight forward-pass smoke tests for the restoration and joint tagger/parser
+pipelines (tiny randomly-initialized configs — these check the tensor plumbing survives
+refactors, not model quality).
+
+## Reproducing the 10-fold split itself
+
+The split is not an input -- it is constructed by the 13-stage pipeline in
+`data/split_pipeline/` (sentence segmentation, pristine-edition clustering via
+exact/MinHash-LSH/shared-sentence evidence, zone assignment, per-fold exclusion
+masks, documentary decontamination incl. blocklist, bronze back-translation
+filters, verification, manifests). `data/fold_manifests/SPLIT_DESIGN.md`
+documents the design; `fold_k_test_works.tsv.gz` lists every work in fold k's
+test bucket (group id, kind, source, record/char counts, author+title), so the
+"provably never seen" guarantee is checkable work-by-work without rebuilding
+anything.
+
+## Revision naming
+
+The paper's reconstruction revisions v1 and v2 correspond, for historical
+reasons, to configuration files named `finetune_whole_v3_*` and
+`finetune_whole_v4_*` respectively (earlier internal iterations v1/v2 were
+superseded before evaluation and are not part of the release).
+
+## External pieces the harnesses expect
+
+* Meter training data: `MACRONIZER_SRC` must point at a checkout of the
+  `Ericu950/Stoicheia-meter-silver` dataset (silver verse lines + scanner corpus);
+  the Norma benchmark itself comes from `Ericu950/norma`.
+* The Ithaca baseline harness (`insc/eval/ithaca_baseline.py`) expects DeepMind's
+  Ithaca repository cloned at `ithaca_upstream/` and its released checkpoint;
+  the Aeneas harness (`insc/eval/ptp_baseline.py`) expects DeepMind's
+  `predictingthepast` repository and its Greek checkpoint. Both are public
+  third-party releases and are not vendored here.

Stoicheia_demo.ipynb

@@ -0,0 +1,279 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Stoicheia — a character-level model for Ancient Greek\n",
+    "\n",
+    "Stoicheia is a 405M-parameter character-level masked-diffusion encoder for Ancient Greek.\n",
+    "Its input is factored into five aligned planes — letters, word/sentence boundaries,\n",
+    "diacritics, capitalization, punctuation — and **any of them can be set to *unknown* at\n",
+    "inference**. One model therefore reads an edited text, bare *scriptio continua*, and a\n",
+    "lacuna of unknown length, changing nothing but its input.\n",
+    "\n",
+    "This notebook runs the whole release end to end on a free Colab GPU (CPU works too, slower):\n",
+    "\n",
+    "1. restore a lacuna whose width is *not known* in advance\n",
+    "2. pick the restoration model that has provably **never read** your document\n",
+    "3. tag and parse a verse of Homer\n",
+    "4. macronize and scan a line of verse\n",
+    "5. score the macronizer against a hand-annotated benchmark\n",
+    "\n",
+    "Every model and dataset used below is public. Anonymous release accompanying a paper under review.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "%pip install -q --upgrade transformers huggingface_hub safetensors torch datasets\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Restoring a lacuna of unknown width\n",
+    "\n",
+    "The hard case in epigraphy and papyrology is a break whose extent is uncertain, in text that\n",
+    "carries no accents and no word division. Write `[N±M]` and the model scores every width in\n",
+    "`N-M … N+M` by its own confidence, restoring the letters, the accents and the word boundaries\n",
+    "together.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "import sys, torch\n",
+    "from transformers import AutoModel\n",
+    "from huggingface_hub import hf_hub_download, snapshot_download\n",
+    "\n",
+    "REPO = \"Ericu950/Stoicheia-doc_clean\"   # zero exposure to inscriptions or papyri\n",
+    "model = AutoModel.from_pretrained(REPO, trust_remote_code=True).eval()\n",
+    "\n",
+    "# the processor is a plain helper module, not part of the model classes: fetch it first\n",
+    "hf_hub_download(repo_id=REPO, filename=\"processing_char_bert.py\", local_dir=\".\")\n",
+    "from processing_char_bert import CharBertProcessor\n",
+    "proc = CharBertProcessor()\n",
+    "\n",
+    "# John 1:1 as it would reach us on a damaged, unaccented, unspaced witness\n",
+    "damaged = \"εναρχηηνο[5±3]καιολογοςηνπροστονθεον\"\n",
+    "best, width, candidates = proc.restore_elastic(model, damaged, mask_dia_boundary=True)\n",
+    "print(\"restored :\", best)\n",
+    "print(\"width    :\", width, \"characters\")\n",
+    "for c in candidates[:5]:\n",
+    "    print(\"   \", c)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. The model that has never read your document\n",
+    "\n",
+    "A single fixed train/test split makes a model useless for exactly the documents an editor\n",
+    "cares about. Ten restoration checkpoints are released instead, one per held-out final digit\n",
+    "of the PHI/TM identifier: whatever inscription or papyrus you are working on, one of the ten\n",
+    "has provably never seen it during fine-tuning, and its backbone never saw a documentary text\n",
+    "at all. A reading proposed by *that* model cannot be a memory of the edition you are checking.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "def model_that_never_read(document_id: str) -> str:\n",
+    "    \"\"\"Pick the released checkpoint whose held-out digit matches this document.\"\"\"\n",
+    "    digit = str(document_id).strip()[-1]\n",
+    "    return f\"Ericu950/Stoicheia-restoration-test{digit}\"\n",
+    "\n",
+    "for phi in [\"PHI 12345\", \"PHI 293\", \"TM 8100\"]:\n",
+    "    print(f\"{phi:12s} -> {model_that_never_read(phi)}\")\n",
+    "\n",
+    "# use it exactly like the backbone above\n",
+    "REPO = model_that_never_read(\"PHI 293\")\n",
+    "local = snapshot_download(REPO, allow_patterns=[\"*.py\", \"*.json\"])\n",
+    "sys.path.insert(0, local)\n",
+    "restorer = AutoModel.from_pretrained(REPO, trust_remote_code=True).eval()\n",
+    "\n",
+    "# note the inputs: τηβου and στεφα...ετης carry no accents and no word division.\n",
+    "# accents and spacing are predictions here, not requirements, so the model fills\n",
+    "# the gap and decides where the words end in the same pass.\n",
+    "print(\"\\n\", proc.restore_respaced(restorer, \"ἔδοξεν τηβου-- καὶ τῷ δήμῳ\"))\n",
+    "# -> ἔδοξεν τῇ βουλῇ καὶ τῷ δήμῳ\n",
+    "print(proc.restore_respaced(restorer, \"στεφανῶσαι αὐτὸν χρυσῷ στεφα[3±1]ετης ἕνεκα\"))\n",
+    "# -> στεφανῶσαι αὐτὸν χρυσῷ στεφάνῳ ἀρετῆς ἕνεκα\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Tagging and parsing\n",
+    "\n",
+    "Four heads on one shared backbone — factored XPOS, an edit-script lemmatizer, a UPOS\n",
+    "auxiliary and a biaffine dependency parser — all from a single forward pass.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import snapshot_download\n",
+    "REPO = \"Ericu950/Stoicheia-tagger-parser\"\n",
+    "local = snapshot_download(REPO, allow_patterns=[\"*.json\", \"*.txt\", \"*.py\", \"*.model\"])\n",
+    "sys.path.insert(0, local)\n",
+    "from processing_char_bert_joint import CharBertJointProcessor\n",
+    "\n",
+    "parser_model = AutoModel.from_pretrained(REPO, trust_remote_code=True).eval()\n",
+    "jproc = CharBertJointProcessor.from_pretrained(local)\n",
+    "\n",
+    "words = \"μῆνιν ἄειδε θεὰ Πηληϊάδεω Ἀχιλῆος\".split()\n",
+    "batch = jproc([words])\n",
+    "with torch.no_grad():\n",
+    "    out = parser_model(**batch)\n",
+    "rows = jproc.decode(out, batch, ud=True)\n",
+    "\n",
+    "sent = rows[0] if rows and not isinstance(rows[0], dict) else rows\n",
+    "hdr = ('id', 'form', 'lemma', 'upos', 'head', 'deprel')\n",
+    "print('%3s %-12s%-12s%-8s%4s %s' % hdr)\n",
+    "for i, w in enumerate(sent, 1):\n",
+    "    print('%3d %-12s%-12s%-8s%4s %s' % (i, w['form'], w['lemma'], w['upos'], w['head'], w['deprel']))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Vowel length and metre\n",
+    "\n",
+    "Greek orthography never marks vowel length: α, ι and υ — the *dichrona* — are ambiguous.\n",
+    "Recovering it (*macronization*) is lexical knowledge, and it is the prerequisite for scanning\n",
+    "verse. `Stoicheia-meter` does both at once; `Stoicheia-macronizer` does vowel length alone,\n",
+    "slightly better.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "REPO = \"Ericu950/Stoicheia-meter\"\n",
+    "local = snapshot_download(REPO, allow_patterns=[\"*.json\", \"*.txt\", \"*.py\", \"*.model\"])\n",
+    "sys.path.insert(0, local)\n",
+    "from processing_char_bert_meter import CharBertMeterProcessor\n",
+    "\n",
+    "meter_model = AutoModel.from_pretrained(REPO, trust_remote_code=True).eval()\n",
+    "mproc = CharBertMeterProcessor()\n",
+    "\n",
+    "line = \"ἄνδρα μοι ἔννεπε, μοῦσα, πολύτροπον, ὃς μάλα πολλὰ\"\n",
+    "batch = mproc(line)\n",
+    "with torch.no_grad():\n",
+    "    out = meter_model(**{k: v for k, v in batch.items() if not k.startswith(\"_\")})\n",
+    "print(\"macronized:\", mproc.decode_macronization(out, batch))   # _ long, ^ short\n",
+    "print(\"scanned   :\", mproc.decode_scansion(out, batch))        # [heavy] {light}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Scoring against the benchmark\n",
+    "\n",
+    "*Norma Syllabarum Graecarum* is a hand-annotated benchmark of macronization and\n",
+    "syllabification. Here we score the dedicated macronizer on its test split — every ambiguous\n",
+    "α/ι/υ position, compared against the gold mark.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "import json, re\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "\n",
+    "REPO = \"Ericu950/Stoicheia-macronizer\"\n",
+    "local = snapshot_download(REPO, allow_patterns=[\"*.json\", \"*.txt\", \"*.py\", \"*.model\"])\n",
+    "sys.path.insert(0, local)\n",
+    "mac_model = AutoModel.from_pretrained(REPO, trust_remote_code=True).eval()\n",
+    "\n",
+    "path = hf_hub_download(\"Ericu950/norma\", \"data/test.jsonl\", repo_type=\"dataset\")\n",
+    "rows = [json.loads(l) for l in open(path, encoding=\"utf-8\")]\n",
+    "rows = [r for r in rows if r[\"task\"] == \"macronize\"][:120]   # raise for the full set\n",
+    "\n",
+    "MARKS = re.compile(r\"[_^]\")\n",
+    "n = correct = 0\n",
+    "for r in rows:\n",
+    "    gold = r[\"text\"]\n",
+    "    raw = MARKS.sub(\"\", gold)\n",
+    "    batch = mproc(raw)\n",
+    "    with torch.no_grad():\n",
+    "        out = mac_model(**{k: v for k, v in batch.items() if not k.startswith(\"_\")})\n",
+    "    pred = mproc.decode_macronization(out, batch)\n",
+    "    for g, p in zip(gold, pred):\n",
+    "        pass\n",
+    "    # compare mark-by-mark at the positions the gold marks\n",
+    "    gi = pi = 0\n",
+    "    while gi < len(gold) and pi < len(pred):\n",
+    "        if gold[gi] in \"_^\" and pred[pi] in \"_^\":\n",
+    "            n += 1; correct += (gold[gi] == pred[pi]); gi += 1; pi += 1\n",
+    "        elif gold[gi] in \"_^\":\n",
+    "            n += 1; gi += 1\n",
+    "        elif pred[pi] in \"_^\":\n",
+    "            pi += 1\n",
+    "        else:\n",
+    "            gi += 1; pi += 1\n",
+    "print(f\"macronization accuracy on {len(rows)} lines: {100*correct/max(n,1):.2f}%  ({n} scored positions)\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "**Everything in the release**\n",
+    "\n",
+    "| | |\n",
+    "|---|---|\n",
+    "| 11 pretrained backbones | ten rotated literary folds + one documentary-clean |\n",
+    "| 10 restoration checkpoints | one per held-out PHI/TM digit |\n",
+    "| tagger-parser, meter, macronizer | fine-tuned from the documentary-clean backbone |\n",
+    "| 5 datasets | pretraining corpus, synthetic augmentation, inscriptions, meter silver, benchmark |\n",
+    "\n",
+    "Training and evaluation code, including the split pipeline that produces the decontamination\n",
+    "guarantee, is in the accompanying code repository.\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  },
+  "colab": {
+   "provenance": [],
+   "toc_visible": true
+  },
+  "accelerator": "GPU"
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

analysis/merge_dsh.py

@@ -0,0 +1,71 @@
+"""Merge sharded restore_dsh.py outputs and print the three-way comparison.
+
+Shards are stride slices, so each covers all gap lengths; merging re-weights each
+length by its own sample count rather than averaging shard means (which would be
+wrong whenever shards see different numbers of samples at a length).
+
+The headline "Overall Average CER" in the DSH 41(1) comparison paper (2026) is the mean of the ten
+per-length means, so that is what we report as CER_macro for comparability; the
+sample-weighted CER_micro is printed alongside rather than chosen selectively.
+
+  python3 analysis/merge_dsh.py
+"""
+import glob, json, os
+
+BASE = os.path.join(os.path.dirname(__file__), "dsh")
+
+# Published reference numbers, the DSH 41(1) comparison paper (2026) DSH 41(1) 69-76, recent/unedited sets.
+# Inscriptions verified reproducible from their released per-record predictions
+# (top-1 51.28%, top-20 68.62% reproduced exactly; CER 0.2859 published).
+# Ithaca and papyri rows were scored by us from the released per-record predictions
+# using the verified metric port (our calculate_cer reproduces their stored CER with
+# zero difference, and their published inscription top-1/top-20 to the decimal).
+REF = {
+    "inscr": {
+        "Llama 3.1 8B (DSH 2026)": dict(CER=0.2859, top1=0.5128, top20=0.6862),
+        "Ithaca (Assael et al. 2022)": dict(CER=0.3118, top1=0.4841, top20=0.6067),
+    },
+    "pap": {
+        "Llama 3.1 8B (DSH 2026)": dict(CER=0.3010, top1=0.5037, top20=0.7051),
+        # Ithaca is inscriptions-only: no papyri row exists, by design not omission.
+    },
+}
+
+
+def merge(pattern):
+    per_len, tot, t1, t20 = {}, 0, 0.0, 0.0
+    files = sorted(glob.glob(pattern))
+    for f in files:
+        d = json.load(open(f))
+        for L, v in d.get("by_length", {}).items():
+            a = per_len.setdefault(int(L), dict(n=0, cer=0.0, t1=0.0, t20=0.0))
+            a["n"] += v["n"]
+            a["cer"] += v["CER"] * v["n"]      # back out the sum from the mean
+            a["t1"] += v["top1"] * v["n"]
+            a["t20"] += v["top20"] * v["n"]
+        tot += d["n"]; t1 += d["top1"] * d["n"]; t20 += d["top20"] * d["n"]
+    if not per_len:
+        return None
+    by = {L: dict(n=a["n"], CER=a["cer"] / a["n"], top1=a["t1"] / a["n"],
+                  top20=a["t20"] / a["n"]) for L, a in sorted(per_len.items())}
+    return dict(shards=len(files), n=tot,
+                CER_macro=sum(v["CER"] for v in by.values()) / len(by),
+                CER_micro=sum(v["CER"] * v["n"] for v in by.values()) / tot,
+                top1=t1 / tot, top20=t20 / tot, by_length=by)
+
+
+for tag, name in (("inscr", "RECENT INSCRIPTIONS"), ("pap", "RECENT PAPYRI")):
+    m = merge(f"{BASE}/v4_recent_{tag}_s*.json")
+    print("=" * 72); print(name); print("=" * 72)
+    if not m:
+        print("  (no shard output yet)\n"); continue
+    print(f"  shards={m['shards']}  n={m['n']}")
+    print(f"  {'system':<32}{'CER':>8}{'top-1':>9}{'top-20':>9}")
+    print(f"  {'Stoicheia (ours, 405M)':<32}{m['CER_macro']:>8.4f}{m['top1']:>9.4f}{m['top20']:>9.4f}")
+    for k, v in REF[tag].items():
+        print(f"  {k:<32}{v['CER']:>8.4f}{v['top1']:>9.4f}{v['top20']:>9.4f}")
+    print(f"  (ours sample-weighted CER {m['CER_micro']:.4f}; macro is the comparable one)")
+    print("  per length:")
+    for L, v in m["by_length"].items():
+        print(f"    L={L:<3} n={v['n']:<5} CER={v['CER']:.4f} top1={v['top1']:.4f} top20={v['top20']:.4f}")
+    print()

analysis/merge_ptp.py

@@ -0,0 +1,60 @@
+"""Merge sharded ptp_baseline.py outputs for the Aeneas-Greek (Nature 2025) rows.
+
+Strict shards are per-length files (strict_L{L}_s{i}.json); recent shards are
+stride slices (recent_s{i}.json). Both are merged per length with sample-count
+weighting, then summarized the same two ways as the existing tables:
+  * strict: AVG over L=1..10 of per-length means (the convention of the
+    strict table) -- comparable to the Ithaca/Stoicheia rows there.
+  * recent: macro over lengths + sample-weighted micro, comparable to the
+    uncontaminated table rows.
+
+  python3 analysis/merge_ptp.py
+"""
+import glob, json, os
+
+D = os.path.expandvars("$STOICHEIA_ROOT/ptp_out")
+
+
+def merge(pattern):
+    per = {}
+    err = 0
+    for f in sorted(glob.glob(f"{D}/{pattern}")):
+        d = json.load(open(f))
+        err += d.get("errors", 0)
+        for L, v in d.get("per_L", {}).items():
+            a = per.setdefault(int(L), dict(n=0, cer=0.0, t1=0.0, t20=0.0))
+            a["n"] += v["n"]
+            a["cer"] += v["CER"] * v["n"]
+            a["t1"] += v["top1"] * v["n"]
+            a["t20"] += v["top20"] * v["n"]
+    if not per:
+        return None
+    by = {L: dict(n=a["n"], CER=a["cer"] / a["n"], top1=a["t1"] / a["n"],
+                  top20=a["t20"] / a["n"]) for L, a in sorted(per.items())}
+    n = sum(v["n"] for v in by.values())
+    return dict(errors=err, n=n,
+                CER_macro=sum(v["CER"] for v in by.values()) / len(by),
+                top1=sum(v["top1"] * v["n"] for v in by.values()) / n,
+                top20=sum(v["top20"] * v["n"] for v in by.values()) / n,
+                by_length=by)
+
+
+for name, pat, ref in (
+    ("STRICT (vs Table 1: Ithaca 24.55/63.0/74.9, Stoicheia v4 15.46/74.5/81.7)",
+     "strict_L*_s*.json", 3000),
+    ("RECENT INSCRIPTIONS (vs Table: Ithaca 31.18/48.41/60.67, "
+     "Llama 28.59/51.28/68.62, Stoicheia 20.20/64.41/73.34)",
+     "recent_s*.json", 4111),
+):
+    m = merge(pat)
+    print("=" * 74)
+    print("AENEAS-GREEK 2025 --", name)
+    if not m:
+        print("  (no output yet)")
+        continue
+    done = m["n"]
+    print(f"  n={done}/{ref}  errors={m['errors']}")
+    print(f"  CER={m['CER_macro']:.4f}  top1={m['top1']:.4f}  top20={m['top20']:.4f}")
+    for L, v in m["by_length"].items():
+        print(f"    L={L:<3} n={v['n']:<4} CER={v['CER']:.4f} "
+              f"top1={v['top1']:.4f} top20={v['top20']:.4f}")

analysis/paper_tables.py

@@ -0,0 +1,189 @@
+"""Regenerate every paper table from results already on disk. Reads only; safe to run
+at any time and shows partial state (n=) while jobs are still finishing.
+
+  python3 analysis/paper_tables.py           # all three experiments
+  python3 analysis/paper_tables.py parsing   # documentary | parsing | meter
+"""
+from __future__ import annotations
+import collections, glob, json, os, re, sys
+import numpy as np
+
+GCB=os.path.expandvars("$STOICHEIA_DATA")
+INSC=os.path.expandvars("$STOICHEIA_DATA")
+REPO=os.path.expandvars("$STOICHEIA_ROOT")
+
+def _agg(v): return (np.mean(v), np.std(v), len(v)) if v else (float("nan"), 0.0, 0)
+
+def parsing():
+    print("\n"+"="*78); print("EXPERIMENT 2 -- PARSING (joint tagger+parser, OGA 5 folds x 2 seeds)"); print("="*78)
+    g=collections.defaultdict(list)
+    for d in sorted(glob.glob(f"{GCB}/parser_data/runs/joint_*_f*_s*")):
+        p=os.path.join(d,"test_scores_greedy.json")
+        if not os.path.exists(p): continue
+        j=json.load(open(p))
+        if j.get("las") is None: continue
+        tag=re.sub(r"_f\d+_s\d+$","",os.path.basename(d))
+        # joint_tune_* are single-fold LR-sweep diagnostics -- reported by lr_control(),
+        # not systems for the main table (an n=1 row next to n=10 rows invites misreading)
+        if tag.startswith("joint_tune_"): continue
+        g[tag].append((j["las"], j["uas"], j["xpos_exact"], j["upos"]))
+    if not g: print("  (no results yet)"); return
+    print(f"{'system':<24}{'n':>3}  {'LAS':>15} {'UAS':>8} {'XPOS':>8} {'UPOS':>8}")
+    for tag,v in sorted(g.items(), key=lambda kv:-np.mean([x[0] for x in kv[1]])):
+        m,s,n=_agg([x[0] for x in v])
+        star="  <- ours" if tag=="joint_docclean" else ("  <- pretraining ablation" if tag=="joint_randinit" else "")
+        print(f"{tag.replace('joint_',''):<24}{n:>3}  {m:.4f}+-{s:.4f}  "
+              f"{np.mean([x[1] for x in v]):.4f} {np.mean([x[2] for x in v]):.4f} "
+              f"{np.mean([x[3] for x in v]):.4f}{star}")
+    if g.get("joint_docclean") and g.get("joint_randinit"):
+        a=np.mean([x[0] for x in g["joint_docclean"]]); b=np.mean([x[0] for x in g["joint_randinit"]])
+        print(f"\n  PRETRAINING EFFECT: {100*(a-b):+.1f} LAS points")
+    # Headline margin must be against the STRONGEST baseline at ITS OWN tuned LR, not
+    # against a baseline handicapped by our shared recipe (see lr_control below).
+    if g.get("joint_docclean"):
+        a=np.mean([x[0] for x in g["joint_docclean"]])
+        cands={k:np.mean([x[0] for x in v]) for k,v in g.items()
+               if k not in ("joint_docclean","joint_docclean_long","joint_randinit",
+                            "joint_randinit_long") and len(v)>=8}
+        if cands:
+            bk=max(cands,key=cands.get)
+            print(f"  vs strongest baseline ({bk.replace('joint_','')}, n>=8): "
+                  f"{100*(a-cands[bk]):+.1f} LAS points")
+    if g.get("joint_docclean") and g.get("joint_randinit_long"):
+        a=np.mean([x[0] for x in g["joint_docclean"]])
+        b=np.mean([x[0] for x in g["joint_randinit_long"]])
+        print(f"  PRETRAINING EFFECT (converged random-init): {100*(a-b):+.1f} LAS points")
+
+def lr_control():
+    print("\n" + "-"*78)
+    print("BASELINE-TUNING CONTROL (fold 0 / seed 0): is the shared recipe unfair to the")
+    print("subword baselines? lr_enc swept for them AND for us.")
+    print("-"*78)
+    S=f"{GCB}/parser_data/runs"
+    for enc,label in (("docclean","ours"),("philberta","PhilBerta"),("greberta","GreBerta")):
+        row=[]
+        b=os.path.join(S,f"joint_{enc}_f0_s0","test_scores_greedy.json")
+        if os.path.exists(b): row.append(("1e-04*", json.load(open(b))["las"]))
+        for d in sorted(glob.glob(f"{S}/joint_tune_{enc}_lr*_f0_s0")):
+            q=os.path.join(d,"test_scores_greedy.json")
+            if not os.path.exists(q): continue
+            v=re.search(r"_lr([0-9.e-]+)_f0",os.path.basename(d)).group(1)
+            row.append((f"{float(v):.0e}", json.load(open(q))["las"]))
+        if not row: continue
+        row.sort(key=lambda r: float(r[0].rstrip("*")))
+        best=max(row,key=lambda r:r[1])
+        print(f"  {label:<10} " + "  ".join(f"{k}:{v:.4f}" for k,v in row)
+              + f"   -> best {best[0]} ({best[1]:.4f})")
+    print("  (* = shared recipe used for the main table)")
+
+
+def meter():
+    print("\n"+"="*78); print("EXPERIMENT 3 -- METER (macronization, Norma test, git source, n=2660)"); print("="*78)
+    rows=collections.defaultdict(dict)
+    for f in sorted(glob.glob(f"{REPO}/logs/eval-*.out")):
+        txt=open(f, errors="ignore").read()
+        if "--norma" not in txt: continue
+        mm=re.search(r"model=(\S+)", txt); mt=re.search(r"macron test: (\{.*?\})", txt)
+        if not (mm and mt): continue
+        run=mm.group(1).split("/runs/")[-1].split("/")[0]
+        if not run.startswith("meter_mac_v2"): continue
+        d=json.loads(mt.group(1))
+        rows["random-init" if "randinit" in run else "pretrained"][run]=(
+            d["bal_acc"], d["acc"], d["macro_bal_acc"])
+    if not rows: print("  (no results yet)"); return
+    print(f"{'arm':<14}{'n':>3}  {'balanced acc':>16} {'acc':>8} {'macro-bal':>10}")
+    means={}
+    for arm in ("pretrained","random-init"):
+        v=list(rows.get(arm,{}).values())
+        if not v: continue
+        m,s,n=_agg([x[0] for x in v]); means[arm]=m
+        print(f"{arm:<14}{n:>3}  {m:.4f}+-{s:.4f}  {np.mean([x[1] for x in v]):.4f} "
+              f"{np.mean([x[2] for x in v]):.4f}")
+    if len(means)==2:
+        print(f"\n  PRETRAINING EFFECT: {100*(means['pretrained']-means['random-init']):+.1f} points balanced accuracy")
+
+def documentary():
+    print("\n"+"="*78); print("EXPERIMENT 1 -- DOCUMENTARY RECONSTRUCTION (inscriptions + papyri)"); print("="*78)
+    prot={"iphi_whole_unk":"inscriptions, whole-doc (no meta)",
+          "iphi_clean_unk":"inscriptions, clean ctx (no meta)",
+          "iphi_whole_meta":"inscriptions, whole-doc (+meta)",
+          "pap_whole_unk":"papyri, whole-doc (no meta)"}
+    for ver,label in (("v4","v4 (6-tier mix, pilot)"),
+                      ("v3","v3 (pretrained)"),
+                      ("v3_randinit","v3 RANDOM-INIT (pretraining ablation)"),
+                      ("v2","v2 (undertrained, superseded)")):
+        agg=collections.defaultdict(list)
+        for f in glob.glob(f"{REPO}/.scratch/evals/{ver}_t*.json"):
+            p=os.path.basename(f)[len(ver)+1:-5][5:]
+            if p not in prot: continue
+            d=json.load(open(f)); agg[p].append((d["avg"]["CER"], d["avg"]["top1"], d["avg"]["top20"]))
+        if not agg: continue
+        print(f"\n  -- {label} --")
+        for k,lab in prot.items():
+            if k not in agg: continue
+            m,s,n=_agg([x[0] for x in agg[k]])
+            print(f"    {lab:<36} n={n:>2}  CER={m:.4f}+-{s:.4f}  "
+                  f"top1={np.mean([x[1] for x in agg[k]]):.4f}  top20={np.mean([x[2] for x in agg[k]]):.4f}")
+    print("\n  -- STRICT Ithaca-comparable (PHI digit-3 test, whole inscriptions,")
+    print("     real lacunae in context, SPACES COUNTED, beam 20, no metadata) --")
+    def merge(files):
+        a=collections.defaultdict(lambda: dict(n=0,cer=0.0,cl=0.0,t1=0.0,t20=0.0))
+        for f in files:
+            try: d=json.load(open(f))
+            except Exception: continue
+            for r in d.get("per_L",[]):
+                x=a[r["L"]]; n=r["n"]; x["n"]+=n; x["cer"]+=r["CER"]*n
+                x["cl"]+=(r.get("CER_letters") or 0)*n; x["t1"]+=r["top1"]*n; x["t20"]+=r["top20"]*n
+        return a
+    for tag,pat in (("Ithaca (DeepMind release)", f"{INSC}/strict_f3/ithaca_shard*.json"),
+                    ("ours old (both_ft_docclean)", f"{INSC}/strict_f3/ours_old.json"),
+                    ("ours v2 (undertrained)", f"{INSC}/strict_f3/ours_v2_shard*.json"),
+                    ("ours v3", f"{INSC}/strict_f3/ours_v3_shard*.json"),
+                    ("ours v4 (pilot)", f"{INSC}/strict_f3/ours_v4_shard*.json")):
+        fs=sorted(glob.glob(pat))
+        if not fs: continue
+        a=merge(fs)
+        if not a: continue
+        Ls=sorted(a)
+        cer=np.mean([a[L]["cer"]/max(a[L]["n"],1) for L in Ls])
+        cl=np.mean([a[L]["cl"]/max(a[L]["n"],1) for L in Ls])
+        t1=np.mean([a[L]["t1"]/max(a[L]["n"],1) for L in Ls])
+        t20=np.mean([a[L]["t20"]/max(a[L]["n"],1) for L in Ls])
+        ntot=sum(a[L]["n"] for L in Ls)
+        extra=f"  CER_let={cl:.4f}" if cl>0 else ""
+        print(f"    {tag:<30} CER={cer:.4f}{extra}  top1={t1:.4f}  top20={t20:.4f}  (n={ntot})")
+
+def scanner():
+    print("\n" + "="*78)
+    print("EXPERIMENT 3b -- SCANNER (Norma syllabify test, joint model, git source)")
+    print("="*78)
+    rows=collections.defaultdict(dict)
+    for f in sorted(glob.glob(f"{REPO}/logs/eval-*.out")):
+        t=open(f,errors="ignore").read()
+        mm=re.search(r"model=(\S+)",t); ms=re.search(r"norma syllabify \(test\) ===\n  (\{.*?\})",t)
+        if not(mm and ms): continue
+        run=mm.group(1).split("/runs/")[-1].split("/")[0]
+        # joint_pilot is an older, different config -- not part of the seed-matched ablation
+        if not run.startswith("meter_joint") or run=="meter_joint_pilot": continue
+        d=json.loads(ms.group(1))
+        arm="random-init" if "randinit" in run else "pretrained"
+        rows[arm][run]=(d["bal_acc"], d["acc"], d["boundary_f1"])
+    if not rows: print("  (no results yet)"); return
+    print(f"{'arm':<14}{'n':>3}  {'balanced acc':>16} {'acc':>8} {'boundary F1':>12}")
+    means={}
+    for arm in ("pretrained","random-init"):
+        v=list(rows.get(arm,{}).values())
+        if not v: continue
+        m,sd,n=_agg([x[0] for x in v]); means[arm]=m
+        print(f"{arm:<14}{n:>3}  {m:.4f}+-{sd:.4f}  {np.mean([x[1] for x in v]):.4f} "
+              f"{np.mean([x[2] for x in v]):.4f}")
+    if len(means)==2:
+        print(f"\n  PRETRAINING EFFECT: {100*(means['pretrained']-means['random-init']):+.1f} pts balanced accuracy")
+
+
+if __name__=="__main__":
+    w=sys.argv[1] if len(sys.argv)>1 else "all"
+    if w in ("all","documentary"): documentary()
+    if w in ("all","parsing"): parsing(); lr_control()
+    if w in ("all","meter"): meter(); scanner()
+    print()

analysis/pick_ckpt.py

@@ -0,0 +1,29 @@
+"""Per-fold checkpoint selection on dev CER, using numbers already in the training log.
+
+The v3 runs selected best.pt on bits_per_char, but bpc and dev CER decorrelate late in
+training (r~0.82) -- bpc bottoms out and rises while CER keeps improving. So best.pt can
+be ~0.02 dev CER worse than the run's end state. Both best.pt and last.pt are legitimate
+checkpoints; choosing between them on DEV CER is standard model selection (dev is exactly
+what selection is for) and costs no GPU, because every eval's dev CER is in the log.
+
+  python3 analysis/pick_ckpt.py                # report
+  python3 analysis/pick_ckpt.py --write        # write chosen_ckpt.txt into each run dir
+"""
+import glob, json, os, re, sys
+I=os.path.expandvars("$STOICHEIA_DATA/insc_data/runs")
+write="--write" in sys.argv
+print(f"{'run':<28}{'best.pt cer':>12}{'last.pt cer':>12}  choice")
+for d in sorted(glob.glob(f"{I}/whole_v*")):
+    ev=os.path.join(d,"eval.jsonl")
+    if not os.path.exists(ev): continue
+    rows=[json.loads(l) for l in open(ev)]
+    if not rows: continue
+    # best.pt = argmin bpc (how these runs were selected); last.pt = final eval
+    bb=min(rows,key=lambda r:r["bits_per_char"])
+    last=rows[-1]
+    pick="best.pt" if bb["dev_cer"]<=last["dev_cer"] else "last.pt"
+    gain=abs(bb["dev_cer"]-last["dev_cer"])
+    flag="" if pick=="best.pt" else f"   (+{gain:.4f} CER recovered)"
+    print(f"{os.path.basename(d):<28}{bb['dev_cer']:>12.4f}{last['dev_cer']:>12.4f}  {pick}{flag}")
+    if write:
+        open(os.path.join(d,"chosen_ckpt.txt"),"w").write(pick+"\n")

analysis/sig_all.py

@@ -0,0 +1,164 @@
+"""Paired significance tests for ALL three experiments.
+
+Everything is paired on the unit that was actually replicated -- (fold, seed) for parsing,
+fold for documentary, seed for meter -- so each comparison controls for split difficulty
+and only the system varies. The headline p-value is an EXACT sign-flip permutation test
+(no distributional assumption); note its floor is 2/2^n, so p=0.002 at n=10 is the
+smallest attainable value, not a coincidence. d_z is paired Cohen's d.
+"""
+from __future__ import annotations
+import collections, glob, json, math, os, re, sys
+import numpy as np
+
+GCB=os.path.expandvars("$STOICHEIA_DATA")
+REPO=os.path.expandvars("$STOICHEIA_ROOT")
+
+def _ttest_rel_p(d):
+    """Two-sided paired t-test p-value without scipy (survival fn of |t| via a
+    continued-fraction incomplete beta -- keeps this script dependency-free so the
+    released code needs only numpy)."""
+    n=len(d); sd=d.std(ddof=1)
+    if sd==0 or n<2: return float("nan")
+    t=abs(d.mean())/(sd/np.sqrt(n)); v=n-1
+    x=v/(v+t*t)
+    # regularised incomplete beta I_x(v/2, 1/2) via Lentz continued fraction
+    a,b=v/2.0,0.5
+    lbeta=(math.lgamma(a)+math.lgamma(b)-math.lgamma(a+b))
+    def betacf(a,b,x,itmax=300,eps=3e-16):
+        qab,qap,qam=a+b,a+1.0,a-1.0
+        c=1.0; d_=1.0-qab*x/qap
+        if abs(d_)<1e-30: d_=1e-30
+        d_=1.0/d_; h=d_
+        for m in range(1,itmax+1):
+            m2=2*m
+            aa=m*(b-m)*x/((qam+m2)*(a+m2))
+            d_=1.0+aa*d_;  c=1.0+aa/c
+            if abs(d_)<1e-30: d_=1e-30
+            if abs(c)<1e-30: c=1e-30
+            d_=1.0/d_; h*=d_*c
+            aa=-(a+m)*(qab+m)*x/((a+m2)*(qap+m2))
+            d_=1.0+aa*d_;  c=1.0+aa/c
+            if abs(d_)<1e-30: d_=1e-30
+            if abs(c)<1e-30: c=1e-30
+            d_=1.0/d_; delta=d_*c; h*=delta
+            if abs(delta-1.0)<eps: break
+        return h
+    if x < (a+1.0)/(a+b+2.0):
+        ib=np.exp(a*np.log(x)+b*np.log(1-x)-lbeta)*betacf(a,b,x)/a
+    else:
+        ib=1.0-np.exp(b*np.log(1-x)+a*np.log(x)-lbeta)*betacf(b,a,1-x)/b
+    return float(min(1.0, max(0.0, ib)))
+
+
+def perm_p(diff):
+    n=len(diff); obs=abs(diff.mean())
+    if n<=20:
+        c=t=0
+        for m in range(1<<n):
+            s=np.array([1 if m>>i&1 else -1 for i in range(n)])
+            c+= abs((diff*s).mean())>=obs-1e-12; t+=1
+        return c/t
+    rng=np.random.default_rng(0)
+    s=rng.choice([-1,1],size=(100000,n))
+    return float((np.abs((diff*s).mean(1))>=obs-1e-12).mean())
+
+def report(title, unit, a_name, a, b_name, b, higher_better=True):
+    keys=sorted(set(a)&set(b))
+    if len(keys)<3:
+        print(f"  {a_name} vs {b_name}: only {len(keys)} paired {unit}s -- not testable yet"); return
+    x=np.array([a[k] for k in keys]); y=np.array([b[k] for k in keys])
+    d=(x-y) if higher_better else (y-x)
+    p=perm_p(d); dz=d.mean()/(d.std(ddof=1)+1e-12)
+    t=_ttest_rel_p(d)
+    print(f"  {a_name} vs {b_name}: n={len(keys)} {unit}s  mean diff={d.mean():+.4f}  "
+          f"perm p={p:.2e}  t p={t:.1e}  d_z={dz:.1f}")
+
+def parsing():
+    print("\nPARSING (LAS, paired by fold+seed; higher better)")
+    S=f"{GCB}/parser_data/runs"; g=collections.defaultdict(dict)
+    for d in sorted(glob.glob(f"{S}/joint_*_f*_s*")):
+        f=os.path.join(d,"test_scores_greedy.json")
+        if not os.path.exists(f): continue
+        j=json.load(open(f))
+        if j.get("las") is None: continue
+        b=os.path.basename(d); m=re.search(r"_(f\d+_s\d+)$",b)
+        g[re.sub(r"_f\d+_s\d+$","",b)][m.group(1)]=j["las"]
+    ref=g.get("joint_docclean",{})
+    for k in sorted(g):
+        if k=="joint_docclean": continue
+        # joint_tune_* are single-fold LR-sweep diagnostics (reported separately as the
+        # baseline-tuning control), not systems to significance-test.
+        if k.startswith("joint_tune_"): continue
+        report("", "run", "ours", ref, k.replace("joint_",""), g[k])
+
+def documentary():
+    print("\nDOCUMENTARY (CER, paired by fold; LOWER better)")
+    def load(ver):
+        out={}
+        for f in glob.glob(f"{REPO}/.scratch/evals/{ver}_t*_iphi_whole_unk.json"):
+            tv=re.search(r"_(t\dv\d)_",os.path.basename(f)).group(1)
+            out[tv]=json.load(open(f))["avg"]["CER"]
+        return out
+    v3=load("v3"); ri=load("v3_randinit"); v2=load("v2")
+    if v3 and ri: report("", "fold", "v3", v3, "random-init", ri, higher_better=False)
+    if v3 and v2: report("", "fold", "v3", v3, "v2 (superseded)", v2, higher_better=False)
+    if not v3: print("  (v3 evals not written yet)")
+
+def strict_ithaca():
+    print("\nSTRICT vs ITHACA (top-1/top-20 exact-match, two-proportion z-test, n=3000 each side)")
+    print("  (samples are IDENTICAL on both sides -- same frozen file -- so this unpaired")
+    print("   test is conservative; a paired McNemar test would only be stronger)")
+    INSC=os.path.expandvars("$STOICHEIA_DATA")
+    import collections
+    def merge(pat):
+        a=collections.defaultdict(lambda: dict(n=0,t1=0.0,t20=0.0))
+        for f in glob.glob(pat):
+            try: d=json.load(open(f))
+            except Exception: continue
+            for r in d.get("per_L",[]):
+                x=a[r["L"]]; x["n"]+=r["n"]; x["t1"]+=r["top1"]*r["n"]; x["t20"]+=r["top20"]*r["n"]
+        n=sum(v["n"] for v in a.values())
+        return (n, sum(v["t1"] for v in a.values()), sum(v["t20"] for v in a.values())) if n else None
+    def ztest(k1,n1,k2,n2):
+        p1,p2=k1/n1,k2/n2; p=(k1+k2)/(n1+n2)
+        se=math.sqrt(p*(1-p)*(1/n1+1/n2))
+        z=(p1-p2)/se
+        # two-sided normal sf via erfc
+        pv=math.erfc(abs(z)/math.sqrt(2))
+        return z,pv
+    ith=merge(f"{INSC}/strict_f3/ithaca_shard*.json")
+    if not ith: print("  (ithaca results missing)"); return
+    for tag,pat in (("ours old",f"{INSC}/strict_f3/ours_old.json"),
+                    ("ours v3",f"{INSC}/strict_f3/ours_v3_shard*.json"),
+                    ("ours v4",f"{INSC}/strict_f3/ours_v4_shard*.json")):
+        m=merge(pat)
+        if not m: continue
+        for name,ki,ko in (("top-1",1,1),("top-20",2,2)):
+            z,pv=ztest(m[ki],m[0],ith[ko],ith[0])
+            print(f"  {tag:<9} vs Ithaca {name:<7}: {m[ki]/m[0]:.4f} vs {ith[ko]/ith[0]:.4f}"
+                  f"   z={z:+.2f}  p={pv:.2e}")
+
+
+def meter():
+    print("\nMETER (macron balanced acc, paired by seed; higher better)")
+    rows=collections.defaultdict(dict)
+    for f in sorted(glob.glob(f"{REPO}/logs/eval-*.out")):
+        txt=open(f,errors="ignore").read()
+        if "--norma" not in txt: continue
+        mm=re.search(r"model=(\S+)",txt); mt=re.search(r"macron test: (\{.*?\})",txt)
+        if not(mm and mt): continue
+        run=mm.group(1).split("/runs/")[-1].split("/")[0]
+        if not run.startswith("meter_mac_v2"): continue
+        seed=re.search(r"_s(\d)$",run); seed=seed.group(1) if seed else "0"
+        arm="randinit" if "randinit" in run else "pretrained"
+        rows[arm][seed]=json.loads(mt.group(1))["bal_acc"]
+    if rows.get("pretrained") and rows.get("randinit"):
+        report("", "seed", "pretrained", rows["pretrained"], "random-init", rows["randinit"])
+    else: print("  (not enough scored runs yet)")
+
+if __name__=="__main__":
+    w=sys.argv[1] if len(sys.argv)>1 else "all"
+    if w in ("all","parsing"): parsing()
+    if w in ("all","documentary"): documentary(); strict_ithaca()
+    if w in ("all","meter"): meter()
+    print()

configs/insc/finetune_whole_v3_randinit_t0v1.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t0v1",
+  "test_digit": "0",
+  "val_digit": "1",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t0v1"
+}

configs/insc/finetune_whole_v3_randinit_t1v2.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t1v2",
+  "test_digit": "1",
+  "val_digit": "2",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t1v2"
+}

configs/insc/finetune_whole_v3_randinit_t2v3.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t2v3",
+  "test_digit": "2",
+  "val_digit": "3",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t2v3"
+}

configs/insc/finetune_whole_v3_randinit_t3v4.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t3v4",
+  "test_digit": "3",
+  "val_digit": "4",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t3v4"
+}

configs/insc/finetune_whole_v3_randinit_t4v5.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t4v5",
+  "test_digit": "4",
+  "val_digit": "5",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t4v5"
+}

configs/insc/finetune_whole_v3_randinit_t5v6.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t5v6",
+  "test_digit": "5",
+  "val_digit": "6",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t5v6"
+}

configs/insc/finetune_whole_v3_randinit_t6v7.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t6v7",
+  "test_digit": "6",
+  "val_digit": "7",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t6v7"
+}

configs/insc/finetune_whole_v3_randinit_t7v8.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t7v8",
+  "test_digit": "7",
+  "val_digit": "8",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t7v8"
+}

configs/insc/finetune_whole_v3_randinit_t8v9.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t8v9",
+  "test_digit": "8",
+  "val_digit": "9",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t8v9"
+}

configs/insc/finetune_whole_v3_randinit_t9v0.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_randinit_t9v0",
+  "test_digit": "9",
+  "val_digit": "0",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "random",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_randinit_t9v0"
+}

configs/insc/finetune_whole_v3_t0v1.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t0v1",
+  "test_digit": "0",
+  "val_digit": "1",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t0v1"
+}

configs/insc/finetune_whole_v3_t1v2.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t1v2",
+  "test_digit": "1",
+  "val_digit": "2",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t1v2"
+}

configs/insc/finetune_whole_v3_t2v3.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t2v3",
+  "test_digit": "2",
+  "val_digit": "3",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t2v3"
+}

configs/insc/finetune_whole_v3_t3v4.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t3v4",
+  "test_digit": "3",
+  "val_digit": "4",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t3v4"
+}

configs/insc/finetune_whole_v3_t4v5.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t4v5",
+  "test_digit": "4",
+  "val_digit": "5",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t4v5"
+}

configs/insc/finetune_whole_v3_t5v6.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t5v6",
+  "test_digit": "5",
+  "val_digit": "6",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t5v6"
+}

configs/insc/finetune_whole_v3_t6v7.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t6v7",
+  "test_digit": "6",
+  "val_digit": "7",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t6v7"
+}

configs/insc/finetune_whole_v3_t7v8.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t7v8",
+  "test_digit": "7",
+  "val_digit": "8",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t7v8"
+}

configs/insc/finetune_whole_v3_t8v9.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t8v9",
+  "test_digit": "8",
+  "val_digit": "9",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t8v9"
+}

configs/insc/finetune_whole_v3_t9v0.json

@@ -0,0 +1,49 @@
+{
+  "name": "whole_v3_t9v0",
+  "test_digit": "9",
+  "val_digit": "0",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 4096,
+  "micro_batch": 8,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "papyri": 1.0
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v3_t9v0"
+}

configs/insc/finetune_whole_v4_t0v1.json

@@ -0,0 +1,55 @@
+{
+ "name": "whole_v4_t0v1",
+ "test_digit": "0",
+ "val_digit": "1",
+ "seed": 0,
+ "d_model": 1024,
+ "depth": 32,
+ "char_window": 256,
+ "attn": "flex",
+ "compile": true,
+ "seq_len": 8192,
+ "micro_batch": 4,
+ "grad_accum": 2,
+ "lr": 0.0001,
+ "wd": 0.1,
+ "warmup": 200,
+ "total_steps": 6000,
+ "decay_len": 1500,
+ "eval_every": 1000000000,
+ "eval_n": 256,
+ "dev_cer_n_per_L": 60,
+ "dev_cer_L_max": 20,
+ "stall_window": 8,
+ "stall_eps": 0.002,
+ "anneal_patience": 3,
+ "log_every": 20,
+ "lam": 0.1,
+ "meta_condition": true,
+ "min_len": 20,
+ "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+ "mix": {
+  "iphi": 1.0,
+  "iphi_syn": 0.5,
+  "papyri": 1.0,
+  "iphi_seg": 0.5,
+  "pap_seg": 0.3,
+  "literary": 0.3,
+  "literary_n": 60000
+ },
+ "noise": {
+  "w_span": 0.45,
+  "w_word": 0.15,
+  "w_elastic": 0.05,
+  "w_iid": 0.15,
+  "w_halfword": 0.15,
+  "w_substitute": 0.05,
+  "span_mean": 4.0,
+  "span_max": 12,
+  "p_region_none": 0.3,
+  "p_century_none": 0.3
+ },
+ "dev_exclude": "",
+ "out_dir": "$INS_DATA/runs/whole_v4_t0v1",
+ "save_every": 500
+}

configs/insc/finetune_whole_v4_t1v2.json

@@ -0,0 +1,55 @@
+{
+ "name": "whole_v4_t1v2",
+ "test_digit": "1",
+ "val_digit": "2",
+ "seed": 0,
+ "d_model": 1024,
+ "depth": 32,
+ "char_window": 256,
+ "attn": "flex",
+ "compile": true,
+ "seq_len": 8192,
+ "micro_batch": 4,
+ "grad_accum": 2,
+ "lr": 0.0001,
+ "wd": 0.1,
+ "warmup": 200,
+ "total_steps": 6000,
+ "decay_len": 1500,
+ "eval_every": 1000000000,
+ "eval_n": 256,
+ "dev_cer_n_per_L": 60,
+ "dev_cer_L_max": 20,
+ "stall_window": 8,
+ "stall_eps": 0.002,
+ "anneal_patience": 3,
+ "log_every": 20,
+ "lam": 0.1,
+ "meta_condition": true,
+ "min_len": 20,
+ "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+ "mix": {
+  "iphi": 1.0,
+  "iphi_syn": 0.5,
+  "papyri": 1.0,
+  "iphi_seg": 0.5,
+  "pap_seg": 0.3,
+  "literary": 0.3,
+  "literary_n": 60000
+ },
+ "noise": {
+  "w_span": 0.45,
+  "w_word": 0.15,
+  "w_elastic": 0.05,
+  "w_iid": 0.15,
+  "w_halfword": 0.15,
+  "w_substitute": 0.05,
+  "span_mean": 4.0,
+  "span_max": 12,
+  "p_region_none": 0.3,
+  "p_century_none": 0.3
+ },
+ "dev_exclude": "",
+ "out_dir": "$INS_DATA/runs/whole_v4_t1v2",
+ "save_every": 0
+}

configs/insc/finetune_whole_v4_t2v3.json

@@ -0,0 +1,55 @@
+{
+ "name": "whole_v4_t2v3",
+ "test_digit": "2",
+ "val_digit": "3",
+ "seed": 0,
+ "d_model": 1024,
+ "depth": 32,
+ "char_window": 256,
+ "attn": "flex",
+ "compile": true,
+ "seq_len": 8192,
+ "micro_batch": 4,
+ "grad_accum": 2,
+ "lr": 0.0001,
+ "wd": 0.1,
+ "warmup": 200,
+ "total_steps": 6000,
+ "decay_len": 1500,
+ "eval_every": 1000000000,
+ "eval_n": 256,
+ "dev_cer_n_per_L": 60,
+ "dev_cer_L_max": 20,
+ "stall_window": 8,
+ "stall_eps": 0.002,
+ "anneal_patience": 3,
+ "log_every": 20,
+ "lam": 0.1,
+ "meta_condition": true,
+ "min_len": 20,
+ "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+ "mix": {
+  "iphi": 1.0,
+  "iphi_syn": 0.5,
+  "papyri": 1.0,
+  "iphi_seg": 0.5,
+  "pap_seg": 0.3,
+  "literary": 0.3,
+  "literary_n": 60000
+ },
+ "noise": {
+  "w_span": 0.45,
+  "w_word": 0.15,
+  "w_elastic": 0.05,
+  "w_iid": 0.15,
+  "w_halfword": 0.15,
+  "w_substitute": 0.05,
+  "span_mean": 4.0,
+  "span_max": 12,
+  "p_region_none": 0.3,
+  "p_century_none": 0.3
+ },
+ "dev_exclude": "",
+ "out_dir": "$INS_DATA/runs/whole_v4_t2v3",
+ "save_every": 500
+}

configs/insc/finetune_whole_v4_t3v4.json

@@ -0,0 +1,54 @@
+{
+  "name": "whole_v4_t3v4",
+  "test_digit": "3",
+  "val_digit": "4",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 8192,
+  "micro_batch": 4,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "iphi_syn": 0.5,
+    "papyri": 1.0,
+    "iphi_seg": 0.5,
+    "pap_seg": 0.3,
+    "literary": 0.3,
+    "literary_n": 60000
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v4_t3v4"
+}

configs/insc/finetune_whole_v4_t3v4_seed1.json

@@ -0,0 +1,54 @@
+{
+ "name": "whole_v4_t3v4_seed1",
+ "test_digit": "3",
+ "val_digit": "4",
+ "seed": 1,
+ "d_model": 1024,
+ "depth": 32,
+ "char_window": 256,
+ "attn": "flex",
+ "compile": true,
+ "seq_len": 8192,
+ "micro_batch": 4,
+ "grad_accum": 2,
+ "lr": 0.0001,
+ "wd": 0.1,
+ "warmup": 200,
+ "total_steps": 14000,
+ "decay_len": 1500,
+ "eval_every": 250,
+ "eval_n": 256,
+ "dev_cer_n_per_L": 60,
+ "dev_cer_L_max": 20,
+ "stall_window": 8,
+ "stall_eps": 0.002,
+ "anneal_patience": 3,
+ "log_every": 20,
+ "lam": 0.1,
+ "meta_condition": true,
+ "min_len": 20,
+ "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+ "mix": {
+  "iphi": 1.0,
+  "iphi_syn": 0.5,
+  "papyri": 1.0,
+  "iphi_seg": 0.5,
+  "pap_seg": 0.3,
+  "literary": 0.3,
+  "literary_n": 60000
+ },
+ "noise": {
+  "w_span": 0.45,
+  "w_word": 0.15,
+  "w_elastic": 0.05,
+  "w_iid": 0.15,
+  "w_halfword": 0.15,
+  "w_substitute": 0.05,
+  "span_mean": 4.0,
+  "span_max": 12,
+  "p_region_none": 0.3,
+  "p_century_none": 0.3
+ },
+ "dev_exclude": "",
+ "out_dir": "$INS_DATA/runs/whole_v4_t3v4_seed1"
+}

configs/insc/finetune_whole_v4_t3v4_seed2.json

@@ -0,0 +1,54 @@
+{
+ "name": "whole_v4_t3v4_seed2",
+ "test_digit": "3",
+ "val_digit": "4",
+ "seed": 2,
+ "d_model": 1024,
+ "depth": 32,
+ "char_window": 256,
+ "attn": "flex",
+ "compile": true,
+ "seq_len": 8192,
+ "micro_batch": 4,
+ "grad_accum": 2,
+ "lr": 0.0001,
+ "wd": 0.1,
+ "warmup": 200,
+ "total_steps": 14000,
+ "decay_len": 1500,
+ "eval_every": 250,
+ "eval_n": 256,
+ "dev_cer_n_per_L": 60,
+ "dev_cer_L_max": 20,
+ "stall_window": 8,
+ "stall_eps": 0.002,
+ "anneal_patience": 3,
+ "log_every": 20,
+ "lam": 0.1,
+ "meta_condition": true,
+ "min_len": 20,
+ "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+ "mix": {
+  "iphi": 1.0,
+  "iphi_syn": 0.5,
+  "papyri": 1.0,
+  "iphi_seg": 0.5,
+  "pap_seg": 0.3,
+  "literary": 0.3,
+  "literary_n": 60000
+ },
+ "noise": {
+  "w_span": 0.45,
+  "w_word": 0.15,
+  "w_elastic": 0.05,
+  "w_iid": 0.15,
+  "w_halfword": 0.15,
+  "w_substitute": 0.05,
+  "span_mean": 4.0,
+  "span_max": 12,
+  "p_region_none": 0.3,
+  "p_century_none": 0.3
+ },
+ "dev_exclude": "",
+ "out_dir": "$INS_DATA/runs/whole_v4_t3v4_seed2"
+}

configs/insc/finetune_whole_v4_t4v5.json

@@ -0,0 +1,55 @@
+{
+ "name": "whole_v4_t4v5",
+ "test_digit": "4",
+ "val_digit": "5",
+ "seed": 0,
+ "d_model": 1024,
+ "depth": 32,
+ "char_window": 256,
+ "attn": "flex",
+ "compile": true,
+ "seq_len": 8192,
+ "micro_batch": 4,
+ "grad_accum": 2,
+ "lr": 0.0001,
+ "wd": 0.1,
+ "warmup": 200,
+ "total_steps": 6000,
+ "decay_len": 1500,
+ "eval_every": 1000000000,
+ "eval_n": 256,
+ "dev_cer_n_per_L": 60,
+ "dev_cer_L_max": 20,
+ "stall_window": 8,
+ "stall_eps": 0.002,
+ "anneal_patience": 3,
+ "log_every": 20,
+ "lam": 0.1,
+ "meta_condition": true,
+ "min_len": 20,
+ "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+ "mix": {
+  "iphi": 1.0,
+  "iphi_syn": 0.5,
+  "papyri": 1.0,
+  "iphi_seg": 0.5,
+  "pap_seg": 0.3,
+  "literary": 0.3,
+  "literary_n": 60000
+ },
+ "noise": {
+  "w_span": 0.45,
+  "w_word": 0.15,
+  "w_elastic": 0.05,
+  "w_iid": 0.15,
+  "w_halfword": 0.15,
+  "w_substitute": 0.05,
+  "span_mean": 4.0,
+  "span_max": 12,
+  "p_region_none": 0.3,
+  "p_century_none": 0.3
+ },
+ "dev_exclude": "",
+ "out_dir": "$INS_DATA/runs/whole_v4_t4v5",
+ "save_every": 0
+}

configs/insc/finetune_whole_v4_t5v6.json

@@ -0,0 +1,55 @@
+{
+ "name": "whole_v4_t5v6",
+ "test_digit": "5",
+ "val_digit": "6",
+ "seed": 0,
+ "d_model": 1024,
+ "depth": 32,
+ "char_window": 256,
+ "attn": "flex",
+ "compile": true,
+ "seq_len": 8192,
+ "micro_batch": 4,
+ "grad_accum": 2,
+ "lr": 0.0001,
+ "wd": 0.1,
+ "warmup": 200,
+ "total_steps": 6000,
+ "decay_len": 1500,
+ "eval_every": 1000000000,
+ "eval_n": 256,
+ "dev_cer_n_per_L": 60,
+ "dev_cer_L_max": 20,
+ "stall_window": 8,
+ "stall_eps": 0.002,
+ "anneal_patience": 3,
+ "log_every": 20,
+ "lam": 0.1,
+ "meta_condition": true,
+ "min_len": 20,
+ "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+ "mix": {
+  "iphi": 1.0,
+  "iphi_syn": 0.5,
+  "papyri": 1.0,
+  "iphi_seg": 0.5,
+  "pap_seg": 0.3,
+  "literary": 0.3,
+  "literary_n": 60000
+ },
+ "noise": {
+  "w_span": 0.45,
+  "w_word": 0.15,
+  "w_elastic": 0.05,
+  "w_iid": 0.15,
+  "w_halfword": 0.15,
+  "w_substitute": 0.05,
+  "span_mean": 4.0,
+  "span_max": 12,
+  "p_region_none": 0.3,
+  "p_century_none": 0.3
+ },
+ "dev_exclude": "",
+ "out_dir": "$INS_DATA/runs/whole_v4_t5v6",
+ "save_every": 500
+}

configs/insc/finetune_whole_v4_t6v7.json

@@ -0,0 +1,54 @@
+{
+  "name": "whole_v4_t6v7",
+  "test_digit": "6",
+  "val_digit": "7",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 8192,
+  "micro_batch": 4,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "iphi_syn": 0.5,
+    "papyri": 1.0,
+    "iphi_seg": 0.5,
+    "pap_seg": 0.3,
+    "literary": 0.3,
+    "literary_n": 60000
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v4_t6v7"
+}

configs/insc/finetune_whole_v4_t7v8.json

@@ -0,0 +1,54 @@
+{
+  "name": "whole_v4_t7v8",
+  "test_digit": "7",
+  "val_digit": "8",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 8192,
+  "micro_batch": 4,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "iphi_syn": 0.5,
+    "papyri": 1.0,
+    "iphi_seg": 0.5,
+    "pap_seg": 0.3,
+    "literary": 0.3,
+    "literary_n": 60000
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v4_t7v8"
+}

configs/insc/finetune_whole_v4_t8v9.json

@@ -0,0 +1,54 @@
+{
+ "name": "whole_v4_t8v9",
+ "test_digit": "8",
+ "val_digit": "9",
+ "seed": 0,
+ "d_model": 1024,
+ "depth": 32,
+ "char_window": 256,
+ "attn": "flex",
+ "compile": true,
+ "seq_len": 8192,
+ "micro_batch": 4,
+ "grad_accum": 2,
+ "lr": 0.0001,
+ "wd": 0.1,
+ "warmup": 200,
+ "total_steps": 8600,
+ "decay_len": 1500,
+ "eval_every": 250,
+ "eval_n": 256,
+ "dev_cer_n_per_L": 60,
+ "dev_cer_L_max": 20,
+ "stall_window": 8,
+ "stall_eps": 0.002,
+ "anneal_patience": 3,
+ "log_every": 20,
+ "lam": 0.1,
+ "meta_condition": true,
+ "min_len": 20,
+ "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+ "mix": {
+  "iphi": 1.0,
+  "iphi_syn": 0.5,
+  "papyri": 1.0,
+  "iphi_seg": 0.5,
+  "pap_seg": 0.3,
+  "literary": 0.3,
+  "literary_n": 60000
+ },
+ "noise": {
+  "w_span": 0.45,
+  "w_word": 0.15,
+  "w_elastic": 0.05,
+  "w_iid": 0.15,
+  "w_halfword": 0.15,
+  "w_substitute": 0.05,
+  "span_mean": 4.0,
+  "span_max": 12,
+  "p_region_none": 0.3,
+  "p_century_none": 0.3
+ },
+ "dev_exclude": "",
+ "out_dir": "$INS_DATA/runs/whole_v4_t8v9"
+}

configs/insc/finetune_whole_v4_t9v0.json

@@ -0,0 +1,54 @@
+{
+  "name": "whole_v4_t9v0",
+  "test_digit": "9",
+  "val_digit": "0",
+  "seed": 0,
+  "d_model": 1024,
+  "depth": 32,
+  "char_window": 256,
+  "attn": "flex",
+  "compile": true,
+  "seq_len": 8192,
+  "micro_batch": 4,
+  "grad_accum": 2,
+  "lr": 0.0001,
+  "wd": 0.1,
+  "warmup": 200,
+  "total_steps": 14000,
+  "decay_len": 1500,
+  "eval_every": 250,
+  "eval_n": 256,
+  "dev_cer_n_per_L": 60,
+  "dev_cer_L_max": 20,
+  "stall_window": 8,
+  "stall_eps": 0.002,
+  "anneal_patience": 3,
+  "log_every": 20,
+  "lam": 0.1,
+  "meta_condition": true,
+  "min_len": 20,
+  "torso": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "mix": {
+    "iphi": 1.0,
+    "iphi_syn": 0.5,
+    "papyri": 1.0,
+    "iphi_seg": 0.5,
+    "pap_seg": 0.3,
+    "literary": 0.3,
+    "literary_n": 60000
+  },
+  "noise": {
+    "w_span": 0.45,
+    "w_word": 0.15,
+    "w_elastic": 0.05,
+    "w_iid": 0.15,
+    "w_halfword": 0.15,
+    "w_substitute": 0.05,
+    "span_mean": 4.0,
+    "span_max": 12,
+    "p_region_none": 0.3,
+    "p_century_none": 0.3
+  },
+  "dev_exclude": "",
+  "out_dir": "$INS_DATA/runs/whole_v4_t9v0"
+}

configs/meter/_smoke.json

@@ -0,0 +1,31 @@
+{
+  "name": "meter_smoke",
+  "seed": 0,
+  "ckpt": "$STOICHEIA_DATA/runs/stoicheia_pretrain_staged/best.pt",
+  "out_dir": "$METER_DATA/runs/meter_smoke",
+  "encoded": "$METER_DATA/encoded",
+  "attn": "sdpa",
+  "T": 512,
+  "micro_batch": 2,
+  "eval_micro": 2,
+  "lr_enc": 0.0001,
+  "lr_head": 0.0008,
+  "wd": 0.01,
+  "clip": 1.0,
+  "warmup_frac": 0.1,
+  "epochs": 2,
+  "patience": 2,
+  "head_dropout": 0.33,
+  "use_cap": true,
+  "scalar_mix": true,
+  "w_mac": 1.0,
+  "w_scan": 1.0,
+  "select": "mean",
+  "prose_per_epoch": 64,
+  "scan_passes": 1,
+  "scan_max_verses": 8,
+  "mac_class_w": "auto",
+  "scan_class_w": "auto",
+  "log_every": 1,
+  "max_records": 64
+}

configs/meter/joint_docclean.json

@@ -0,0 +1,30 @@
+{
+  "name": "meter_joint_docclean",
+  "seed": 0,
+  "ckpt": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "out_dir": "$STOICHEIA_DATA/runs/meter_joint_docclean",
+  "encoded": "$METER_DATA/encoded",
+  "attn": "sdpa",
+  "T": 2048,
+  "micro_batch": 16,
+  "eval_micro": 16,
+  "lr_enc": 0.0001,
+  "lr_head": 0.0008,
+  "wd": 0.01,
+  "clip": 1.0,
+  "warmup_frac": 0.1,
+  "epochs": 25,
+  "patience": 6,
+  "head_dropout": 0.33,
+  "use_cap": true,
+  "scalar_mix": true,
+  "w_mac": 1.0,
+  "w_scan": 1.0,
+  "select": "mean",
+  "prose_per_epoch": 150000,
+  "scan_passes": 2,
+  "scan_max_verses": 8,
+  "mac_class_w": "auto",
+  "scan_class_w": "auto",
+  "log_every": 50
+}

configs/meter/joint_docclean_s1.json

@@ -0,0 +1,30 @@
+{
+  "name": "meter_joint_docclean_s1",
+  "seed": 1,
+  "ckpt": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "out_dir": "$STOICHEIA_DATA/runs/meter_joint_docclean_s1",
+  "encoded": "$METER_DATA/encoded",
+  "attn": "sdpa",
+  "T": 2048,
+  "micro_batch": 16,
+  "eval_micro": 16,
+  "lr_enc": 0.0001,
+  "lr_head": 0.0008,
+  "wd": 0.01,
+  "clip": 1.0,
+  "warmup_frac": 0.1,
+  "epochs": 25,
+  "patience": 6,
+  "head_dropout": 0.33,
+  "use_cap": true,
+  "scalar_mix": true,
+  "w_mac": 1.0,
+  "w_scan": 1.0,
+  "select": "mean",
+  "prose_per_epoch": 150000,
+  "scan_passes": 2,
+  "scan_max_verses": 8,
+  "mac_class_w": "auto",
+  "scan_class_w": "auto",
+  "log_every": 50
+}

configs/meter/joint_docclean_s2.json

@@ -0,0 +1,30 @@
+{
+  "name": "meter_joint_docclean_s2",
+  "seed": 2,
+  "ckpt": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "out_dir": "$STOICHEIA_DATA/runs/meter_joint_docclean_s2",
+  "encoded": "$METER_DATA/encoded",
+  "attn": "sdpa",
+  "T": 2048,
+  "micro_batch": 16,
+  "eval_micro": 16,
+  "lr_enc": 0.0001,
+  "lr_head": 0.0008,
+  "wd": 0.01,
+  "clip": 1.0,
+  "warmup_frac": 0.1,
+  "epochs": 25,
+  "patience": 6,
+  "head_dropout": 0.33,
+  "use_cap": true,
+  "scalar_mix": true,
+  "w_mac": 1.0,
+  "w_scan": 1.0,
+  "select": "mean",
+  "prose_per_epoch": 150000,
+  "scan_passes": 2,
+  "scan_max_verses": 8,
+  "mac_class_w": "auto",
+  "scan_class_w": "auto",
+  "log_every": 50
+}

configs/meter/joint_docclean_s3.json

@@ -0,0 +1,30 @@
+{
+  "name": "meter_joint_docclean_s3",
+  "seed": 3,
+  "ckpt": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "out_dir": "$STOICHEIA_DATA/runs/meter_joint_docclean_s3",
+  "encoded": "$METER_DATA/encoded",
+  "attn": "sdpa",
+  "T": 2048,
+  "micro_batch": 16,
+  "eval_micro": 16,
+  "lr_enc": 0.0001,
+  "lr_head": 0.0008,
+  "wd": 0.01,
+  "clip": 1.0,
+  "warmup_frac": 0.1,
+  "epochs": 25,
+  "patience": 6,
+  "head_dropout": 0.33,
+  "use_cap": true,
+  "scalar_mix": true,
+  "w_mac": 1.0,
+  "w_scan": 1.0,
+  "select": "mean",
+  "prose_per_epoch": 150000,
+  "scan_passes": 2,
+  "scan_max_verses": 8,
+  "mac_class_w": "auto",
+  "scan_class_w": "auto",
+  "log_every": 50
+}

configs/meter/joint_docclean_s4.json

@@ -0,0 +1,30 @@
+{
+  "name": "meter_joint_docclean_s4",
+  "seed": 4,
+  "ckpt": "$STOICHEIA_DATA/runs/stoicheia_doc_clean/best.pt",
+  "out_dir": "$STOICHEIA_DATA/runs/meter_joint_docclean_s4",
+  "encoded": "$METER_DATA/encoded",
+  "attn": "sdpa",
+  "T": 2048,
+  "micro_batch": 16,
+  "eval_micro": 16,
+  "lr_enc": 0.0001,
+  "lr_head": 0.0008,
+  "wd": 0.01,
+  "clip": 1.0,
+  "warmup_frac": 0.1,
+  "epochs": 25,
+  "patience": 6,
+  "head_dropout": 0.33,
+  "use_cap": true,
+  "scalar_mix": true,
+  "w_mac": 1.0,
+  "w_scan": 1.0,
+  "select": "mean",
+  "prose_per_epoch": 150000,
+  "scan_passes": 2,
+  "scan_max_verses": 8,
+  "mac_class_w": "auto",
+  "scan_class_w": "auto",
+  "log_every": 50
+}