ciscoriordan/open-greek-corpus-annotations

Open Greek Corpus Annotations

Token-level linguistic annotations for the Open Greek Corpus: lemma, part of speech (UD UPOS), and morphology (UD features) for every served token. Three provenance classes, never confused thanks to per-token provenance and confidence tiers: gold treebank annotations where an openly licensed MANUAL treebank covers a work (GLAUx's treebank layers, MACULA Greek for the NT), GLAUx's own automatic annotation as the middle auto: class, and model annotations from dilemma (silver) everywhere else.

Part of the Open Greek project.

Relationship to the corpus repo

The corpus repo owns the text: one JSON Lines file per work (data/corpus/<urn>.jsonl), one record per citable passage ({urn, locus, text, ...}). This repo mirrors that layout with sidecar files (data/annotations/<urn>.jsonl), one annotation record per corpus record, keyed by {urn, locus, text_sha256}. The hash pins each annotation to the exact text it annotates: when the corpus corrects a passage, exactly that record is invalidated and re-annotated, nothing else. Sidecars carry no text of their own beyond the token substrings; the corpus stays the single source of truth for text.

See docs/SCHEMA.md for the full record schema, the versioned tokenizer, the AGDT-to-UD mapping, provenance and tier definitions, and the validation invariants (offsets reconstruct the text exactly).

Status: full corpus

The full run annotates every served corpus work (works added or renamed since the last pass surface as pending until rebuilt; currently 0 of 3,622 - all served works are annotated). Routing (data/manifest.json, built by scripts/build_manifest.py, revised 2026-07-13 with the provenance split and the layer-license gate fix): 3,622 served works; 128 routed to manual gold (101 GLAUx treebank-layered works + the 27 NT works from MACULA as gold:macula), 1,036 to GLAUx's automatic layer (auto:glaux, the middle provenance class), 2,458 to silver; 115 works tag in med mode, the rest grc. GLAUx's annotation status is read PER SENTENCE (build_gold_glaux.glaux_token_label), so a treebank-routed work emits gold:glaux on its hand-corrected sentences and auto:glaux on the automatic gaps GLAUx leaves inside it; most treebank works are only partly hand- annotated, so this split moves ~2.5M tokens out of the treebank-gold headline.

Aligned layers (built, data/coverage.json): 1.08M gold:glaux tokens (100 works, hand-corrected treebank sentences only) + 135K gold:macula tokens (27)

• 16.0M auto:glaux tokens (1,070, including the automatic sentences inside treebank works), 0 build failures; locus join where the source carries loci, whole-work global alignment otherwise (see docs/GOLD_SOURCES.md and docs/SCHEMA.md). Tokens the alignment cannot cover are silver-filled. PROIEL-derived layers (CC BY-NC-SA: the GLAUx NT and Herodotus) are refused by the license gate; the NT is gold via MACULA instead and Herodotus is full silver. OGA was evaluated head-to-head against dilemma and not ingested (docs/OGA_EVAL.md).

Silver layer: the remaining 64M tokens (2,458 silver-only works plus the fill remainder of the aligned works) are annotated by the dilemma tagger + lemmatizer with the non-lexical classifier, mode from the registry era tag. The pass runs as detached, resumable, token-balanced shard workers (scripts/launch_silver.sh -> scripts/run_silver.py). Scheduling is chunk-level: a giant work (the Homer scholia are ~764K whitespace tokens) is split into contiguous row-chunks of at most --chunk-tokens tokens (default 40000) and the chunks are balanced across shards, so no single monster work pins one shard for hours while the rest idle at the tail. Each chunk writes a partial sidecar under data/annotations/.chunks/, and a merge step (automatic at the end of every shard, re-runnable via --merge or scripts/merge_chunks.py) concatenates a work's parts into data/annotations/<urn>.jsonl in row order; a merged sidecar is byte-identical (rows) and stats-identical to a single whole-work build, and small works stay a single chunk (unchanged). See docs/CHUNKING.md. onnxruntime has no env override for its intra-op pool and defaults it to the core count, so each worker's thread pool is capped via GA_ORT_THREADS to keep N workers from oversubscribing the cores; on an 18-core Apple M5 Max, 9 workers x 2 threads measured best (700 tok/s aggregate), a multi-hour background job that survives disconnects and skips works already annotated for the current corpus text.

Calibration (silver vs gold on the gold works, scripts/measure_agreement.py) on Persae, verse drama with dialect lyric and one of the harder settings, was 91.4% lemma / 94.0% UPOS / 92.4% feats / 80.8% all-exact in the pilot; prose works score higher. The production calibration is re-measured against the final dilemma once the silver pass runs. Per-work alignment and agreement reports live in data/reports/.

OG Dilemma layer (scripts/build_dilemma_layer.py): the primary sidecars keep the aligned layer (treebank-gold / GLAUx-auto) on aligned tokens and use dilemma only to fill gaps, so the 23 tiny works GLAUx covered 100% carried no dilemma reading at all. To have an independent OG Dilemma annotation for every token of the 1,164 aligned works, a parallel full-silver sidecar is built for each into data/annotations_dilemma/<urn>.jsonl (token-aligned to the primary, never overwriting it). scripts/measure_dilemma_agreement.py then scores dilemma against the aligned layer, convention-neutral, into data/dilemma_agreement.json. Corpus-wide, OG Dilemma matches GLAUx-auto on 95.3% of the 14.1M shared tokens (96.1% lemma / 98.9% UPOS / 97.6% feats), the GLAUx treebanks (hand-corrected sentences only) on 93.7% (948K tokens), and MACULA on 92.5% - high agreement that is expected, since dilemma trains on GLAUx: the GLAUx-auto and GLAUx-treebank figures are a same-family second opinion (partly train-on-test), not an independent check. The treebank figure is the lowest of the three because the hand corrections are exactly where GLAUx's automatic tags (which dilemma learns) were wrong. Only MACULA is genuinely outside dilemma's training. This drives the reader home's agreement bar.

Layout

data/annotations/<urn>.jsonl   the sidecars (one per work; bulk lives on HF, see below)
data/annotations_dilemma/<urn>.jsonl  parallel OG Dilemma layer over the aligned works (bulk on HF)
data/reports/<urn>.*.json      per-work alignment and agreement reports
data/manifest.json             aligned-layer (gold/auto) vs silver + mode routing per served work
data/coverage.json             aggregate coverage / provenance / tier stats
data/work_annotations.json     per-work token counts by source, exact versioned provenance labels, + an annotator-version registry
data/dilemma_agreement.json    OG Dilemma layer vs each aligned source: agreement %, per source + per work
data/gold_stats.json           LAST gold-pass run summary (per-invocation, not cumulative)
data/sample/                   a handful of committed example sidecars
docs/SCHEMA.md                 the schema (the design document)
docs/GOLD_SOURCES.md           which annotation layers are ingested and why
docs/OGA_EVAL.md               OGA vs dilemma head-to-head evaluation
scripts/ga_tokenizer.py        deterministic offset-bearing tokenizer (versioned)
scripts/agdt_ud.py             AGDT/GLAUx postag -> UD mapping (versioned)
scripts/macula_ud.py           MACULA attributes -> AGDT postag -> UD (versioned)
scripts/treebank_licenses.py   annotation-layer license table + gate helpers
scripts/silver.py              dilemma-based silver annotator (+ non-lexical marking)
scripts/build_manifest.py      build the routing manifest
scripts/build_gold_glaux.py    gold/auto sidecar builder (GLAUx -> corpus rows)
scripts/build_gold_macula.py   gold sidecar builder (MACULA -> the 27 NT works)
scripts/build_gold_batch.py    batch gold builder over all GLAUx-covered works
scripts/relabel_glaux_auto.py  one-time gold:glaux -> auto:glaux migration
scripts/build_silver.py        silver sidecar builder (one work, or a row range)
scripts/run_silver.py          resumable silver driver: chunk-level shards + merge (+ gold-fill)
scripts/merge_chunks.py        assemble chunk parts into final sidecars (= run_silver.py --merge)
scripts/launch_silver.sh       launch N detached silver shard workers
scripts/build_dilemma_layer.py    parallel OG Dilemma layer over the aligned works (sharded)
scripts/measure_dilemma_agreement.py  OG Dilemma layer vs the aligned layer -> data/dilemma_agreement.json
scripts/build_stats.py         aggregate + per-work stats -> data/coverage.json, data/work_annotations.json
scripts/validate_sidecar.py    schema lint + offset round-trip validator
scripts/test_chunk_merge.py    checks a chunked+merged sidecar == a single-pass one
scripts/measure_agreement.py   silver vs gold scoring on a gold work
scripts/measure_agreement_oga.py  OGA vs gold scoring (aligned, not re-tagged)
scripts/eval_oga_vs_dilemma.py    the OGA/dilemma comparison driver

Where the full sidecar set lives

The full annotation set is several GB, so, like the dilemma data, it is not committed to git. This repo carries the pipeline, the manifest and stats, the per-work reports, and a representative sample under data/sample/; the full data/annotations/ and data/annotations_dilemma/ sets are hosted on the Hugging Face Hub (ciscoriordan/open-greek-corpus-annotations, as annotations/ and annotations_dilemma/) and are regenerable from the pinned corpus revision with the commands below. Both dirs are git-ignored.

Running

Requires Python 3.10+, a checkout of the corpus repo, and (for building, not for consuming) the dilemma package with its tagger extras (pip install "dilemma-nlp[tagger-onnx] @ git+https://github.com/open-greek/dilemma.git" then python -m dilemma download). Gold builds also need a GLAUx checkout and the prosodia package (the shared Open Greek diacritic-compatibility canon the token aligner folds through): pip install -e ancient-greek-prosodia-engine/python, or check it out next to this repo / point $PROSODIA_DIR at it (the aligner imports it, never vendors it). Point the scripts at the checkouts with $COG_DIR / $GLAUX_DIR or --cog-dir / --glaux-dir.

Full run, in order:

export COG_DIR=/path/to/open-greek-corpus GLAUX_DIR=/path/to/glaux

# 1. routing manifest (gold/auto vs silver + tagger mode per served work)
python3 scripts/build_manifest.py

# 2. aligned layers: pure gold:/auto: sidecars for every GLAUx-covered work
#    (dilemma-independent; uncovered tokens left as provenance "none"),
#    then MACULA gold for the 27 NT works (includes its dilemma fill)
python3 scripts/build_gold_batch.py --workers 8
python3 scripts/build_gold_macula.py --cog-dir "$COG_DIR" --all

# 3. silver layer: detached, resumable, token-balanced chunk-level shard workers
#    (fills the gold "none" tokens and builds every silver-only work). Giant
#    works are split into <=CHUNK_TOKENS-token chunks spread across shards and
#    merged back automatically; if a shard crashed before its merge sweep, run
#    `python3 scripts/run_silver.py --cog-dir "$COG_DIR" --merge` to finish.
COG_DIR="$COG_DIR" NSHARD=9 CHUNK_TOKENS=40000 GA_ORT_THREADS=2 bash scripts/launch_silver.sh

# 4. stats + validation
python3 scripts/build_stats.py
python3 scripts/validate_sidecar.py data/annotations/*.jsonl --cog-dir "$COG_DIR"

# silver-vs-gold calibration on a gold work
python3 scripts/measure_agreement.py data/annotations/aeschylus-tragedy.persae.jsonl

Single-work builders (build_gold_glaux.py --urn ... --glaux-id ..., build_silver.py --urn ...) are still available for one-offs.

How the full run will work

1. Inventory: for every corpus work, decide gold vs silver. Gold candidates come from crosswalking the corpus registry's TLG aliases against GLAUx ids (GLAUx covers roughly 1,400 texts, 8th century BCE to 4th century CE); everything else is silver.
2. Gold pass: build_gold_glaux.py per covered work, with the license gate refusing the handful of NonCommercial GLAUx texts. Alignment reports are kept per work; works with poor alignment (cross-edition drift) fall back to silver rather than shipping bad gold.
3. Silver pass: build_silver.py for the rest, mode from the registry era tag. The corpus is ~90M tokens; the tagger runs on CPU at roughly 100 tokens/s per core and batches per work, so the pass is embarrassingly parallel by work.
4. Validation: validate_sidecar.py --cog-dir over everything; CI re-runs it against the pinned corpus revision.
5. Incremental updates: when corpus rows change, their hashes change; a re-annotation pass rebuilds only stale records. When a new tagger or lemmatizer ships, silver works are rebuilt wholesale and the provenance label records the new version; gold records are untouched.

Open design questions are tracked at the end of docs/SCHEMA.md.

Licensing

All annotation data in this repo: CC BY-SA 4.0. Scripts: MIT (see headers where it matters; treat scripts/ as MIT).

Why CC BY-SA 4.0 for the data: the gold layer is derived from ShareAlike sources, and ShareAlike propagates to adaptations. CC BY-SA 3.0 US material (AGDT) may be adapted and released under CC BY-SA 4.0 (a compatible later version), and CC BY 4.0 material may be incorporated into a BY-SA work, so CC BY-SA 4.0 is the least restrictive license that satisfies every source below simultaneously. The silver layer is machine output of an MIT-licensed tool over the corpus texts and is released under the same license for uniformity.

Source inventory:

source	license	role here
GLAUx (Keersmaekers)	CC BY-SA 4.0 (per-text SOURCE_LICENSE; NC texts and NC treebank LAYERS refused by the gate, scripts/treebank_licenses.py)	gold:glaux where a text carries an openly licensed manual layer; auto:glaux (its own automatic annotation) elsewhere
MACULA Greek (Biblica)	CC BY 4.0	gold:macula: the 27 NT works (manually curated Nestle1904 annotation, cross-edition aligned to the served W&H text)
AGDT / Perseus treebanks	CC BY-SA 3.0 US	inside GLAUx's manual layer
Pedalion Trees	CC BY-SA 4.0	inside GLAUx's manual layer
Gorman trees	CC BY-SA 4.0 (the perseids release's TREEBANK_LICENSE; its README says CC0 1.0, and her personal repo is CC BY-NC-SA)	inside GLAUx's manual layer
Harrington Trees	CC BY-SA 4.0	inside GLAUx's manual layer
Diorisis	CC BY 4.0	not ingested; automatically annotated (auto:-class) and subsumed by dilemma's training data
OGA (Celano)	CC BY-SA 4.0	not ingested; all-automatic, evaluated head-to-head vs dilemma (docs/OGA_EVAL.md)
dilemma	MIT (code); openly licensed data throughout	silver annotator (tagger + lemmatizer)
Open Greek Corpus	CC BY-SA 4.0 (aggregate; per-row license field)	the annotated text

Excluded on license grounds: PROIEL (CC BY-NC-SA, no permissive release) and every other NonCommercial treebank or text. The gate checks BOTH the source text license and the annotation layer license (the original run checked only the text, which let the PROIEL-layered GLAUx NT + Herodotus through as gold; fixed 2026-07-13, those works rebuilt from MACULA / silver). A work only available under NC terms gets silver annotations instead.